Literate Programming

January 10, 2018 at 10:43 am | Posted in Hacking, Programming | Leave a comment
Tags: , , , , ,

I was reading Knuth’s The Art of Computer Programming, the seminal in algorithms. I was unable to understand some parts of section 1.2.10 (analysis of an algorithm), so I asked on IRC channels (like ##programming, ##c, #haskell etc.) and I came across More Shell, Less Egg. Go read that article and come back here.

I hope you have finished reading that article. A few years back I came to know about Literate Programming. I was curious about it, I read some articles on it and really loved the concept. Fast forward to 2018, I am a full-time computer programmer with several years of experience now and my thinking has changed. So how does literate programming look now ?

I read full article and was quite impressed by the cleverness and experience of both Mcllroy and Knuth. Now Mcllroy is a UNIX guy (he wrote UNIX pipes). UNIX gurus are very practical and wise when it comes to solving problems. But I found myself little bit wrong in comparing a shell script with a full fledged programming language available on a variety of systems. Then I came across this comment by Charles Wolfe:

most comments tend to become useless rather rapidly and having the documents wholly separated from the code make the cross referencing or consultation of docs to understand code difficult most of the time.

I have to agree with that as per my own experience (it may not be valid all the time and this is how most of the industrial code is written). We combine that with another very practical blog post by Franklin Chen. He used 2 pieces of codes to prove his point, first one, normal Haskell code and 2nd, Haskell code written with documentation (something like Haskell’s own WEB system). If you look carefully you can see that one with documentation is not much readable (at least I felt horrible when I tried to read it).

So, What Do I think now in 2018 after working in software industry ?

Let me make it very clear that Knuth is a brilliant guy, I respect him a lot. I even someday want to learn from him by sitting next to him teaching me 🙂 . We are talking here about Software Industry, the commercial interests. I think Literate Programming will not spread into the software industry. First of all, industrial software developers (at least here in India) do not care much about comments. I do write hell lot of comments but that is because I was learned my skills on USENET whereas most industrial programmers in India learned from usual engineering colleges where commenting your code well, is not part of the picture. There is no paradigm of “you will write it once and it will be read 10000 times, so help your fellow programmers by telling them what are you doing” (I just industrialized the quote from Knuth: “Programs are meant to be read by humans and only incidentally for computers to execute.”).  2nd, there is lot of job-shifting happens in industry. By the time  a project comes to its completion, there is a possibility that  1000 different people have worked  on it who never communicated with each other, hence,  lot of code changes and many times, comments, sooner or later, become irrelevant. Some comments stay same, many don’t. 3rd, managers in industry want solutions fast and even though, most of the time, such attitude hurts the software and hence the company in long term but then I do not think it is their fault because they have pressure on them to deliver. So, if a project takes a month to design, code and test and deliver then you have to get it done by next week. In such cases, all things not related to “fast delivery” are generally ruled out. If it is not a whole project and there is problem you have to solve then  because of “fast delivery” requirements, UNIX tools win. I have experienced both. You can’t beat UNIX tools there with a general purpose language.  So, I think Literate Programming  will never catch up in industry.

Copyright © 2017 Arnuld Uttre, Hyderabd, Telangana – 500017 (INDIA)
Licensed Under Attribution-NoDerivs 3.0 United States (CC BY-ND 3.0 US)

Advertisements

C quiz

January 4, 2018 at 3:30 pm | Posted in Programming | Leave a comment

I was looking at an online C language quiz and came across this:

#include <stdio.h>

int main(void) {
 struct myStruct
  {
    int num = 10;
  }var;

  printf("%d\n", var.num
);

  return 0;
}

This will never compile. Guess why. Because You can’t initialize struct members in declaration. Here is what gcc 7.2.1 will throw:

[arnuld@arch64 programs]$ gcc -ansi -pedantic -Wall -Wextra t.c
t.c: In function ‘main’:
t.c:6:13: error: expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘=’ token
int num = 10;
^
t.c:4:9: warning: struct has no members [-Wpedantic]
struct myStruct
^~~~~~~~
t.c:9:21: error: ‘struct myStruct’ has no member named ‘num’
printf(“%d\n”, var.num
^
t.c:7:4: warning: variable ‘var’ set but not used [-Wunused-but-set-variable]
}var;
^~~
[arnuld@arch64 programs]$

You can do this instead:

#include <stdio.h>

int main(void) {
 struct myStruct
  {
    int num;
  }var;

  var.num = 10;
  printf("%d\n", var.num);

  return 0;
}

Then you get this:

[arnuld@arch64 programs]$ gcc -ansi -pedantic -Wall -Wextra t.c
[arnuld@arch64 programs]$ ./a.out
10
[arnuld@arch64 programs]$

But this will not work:

#include <stdio.h>

struct myStruct
{
  int num;
}var;

int main(void)
{
  var x;
  x.num = -1;
  printf("%d\n", x.num);

  return 0;
}

[arnuld@arch64 programs]$ gcc -ansi -pedantic -Wall -Wextra struct.c
struct.c: In function ‘main’:
struct.c:11:3: warning: statement with no effect [-Wunused-value]
var x;
^~~
struct.c:11:7: error: expected ‘;’ before ‘x’
var x;
^
struct.c:12:3: error: ‘x’ undeclared (first use in this function)
x.num = -1;
^
struct.c:12:3: note: each undeclared identifier is reported only once for each function it appears in
[arnuld@arch64 programs]$

Can you guess why ?

Because /var/ is a myStruct variable, not a type. If you want it to be accessible inside main() then you have to make it a type using typedef, like this:

#include <stdio.h>

typedef struct myStruct
{
  int num;
}var;

int main(void)
{
  var x;
  x.num = -1;
  printf("%d\n", x.num);

  return 0;
}

[arnuld@arch64 programs]$ gcc -ansi -pedantic -Wall -Wextra struct.c
[arnuld@arch64 programs]$ ./a.out
-1
[arnuld@arch64 programs]$

C is a very small language. You can put entire C language in your head if you do few years of serious coding in C. For the standard libraries, you have have H&S5.

Copyright © 2018 Arnuld Uttre, Hyderabd, Telangana – 500017 (INDIA)
Licensed Under Attribution-NoDerivs 3.0 United States (CC BY-ND 3.0 US)

Interview Question — Printing a Palindrome

May 9, 2017 at 4:35 pm | Posted in Programming | Leave a comment

This was asked recently to me in an interview. Problem is explained in the comments:

/* GlobalEdx interview Question, Real Life Practicial Code
*
* If a user enters D then write a program to print like this:
*  A B C D C B A
* If user Enters J or Z then it should print till J or Z
* like above. Program should work for every letter of English
*
*/

#include <stdio.h>

void printPalindrome(char c) ;
int getFirstLetter(char* p, char* pc);

int main(int argc, char* argv[]){
char c;
if(2 != argc) {
printf("Please provide 1 argument\n");
}
else
{
if(!getFirstLetter(argv[1], &c)) printPalindrome(c);
else printf("You did not enter a character. Enter uppercase character \n");
}
return 0;
}

/* If you get more than letter. Just pick up the first letter
*
*/
int getFirstLetter(char* p, char* pc) {
char temp = *p;

/* What if user puts an int or double, here we handle that ? */
if( ((temp >= 'A') && (temp <= 'Z')) ) {
*pc = temp;
return 0;
}
else return 1;
}

void printPalindrome(char c) {
char t;

for(t='A'; t != c; ++t) printf("%c, ", t);
for(; 'A' != t; --t)     printf("%c, ", t);
printf("%c\n", t);
}

OUTPUT:
[arnuld@arch64 programs]$ gcc -ansi -pedantic -Wall -Wextra palindrome.c
[arnuld@arch64 programs]$

[arnuld@arch64 programs]$ ./a.out BA
A, B, A
[arnuld@arch64 programs]$ ./a.out D
A, B, C, D, C, B, A

[arnuld@arch64 programs]$ ./a.out 0
You did not enter a character. Enter uppercase character

[arnuld@arch64 programs]$ ./a.out 0*
You did not enter a character. Enter uppercase character

[arnuld@arch64 programs]$ ./a.out {
You did not enter a character. Enter uppercase character
[arnuld@arch64 programs]$

Copyright © 2017 Arnuld Uttre, Hyderabd, Telangana – 500017 (INDIA)
Licensed Under Attribution-NoDerivs 3.0 United States (CC BY-ND 3.0 US)

HCL Interview

March 28, 2017 at 11:16 am | Posted in Patterns, Programming | Leave a comment

Earlier I wrote about my interview experience with NetCloud Systems Bangalore. Recently I appeared for an interview with HCL Technologies. (HCL Technologies is on the Forbes Global 2000 list.[13] It is among the top 20 largest publicly traded companies in India with a market capitalisation of $22.1 billion as of May 2015.[14] As of August 2015, the company, along with its subsidiaries, had a consolidated revenue of $6.0 billion.[5]  — Source: Wikipedia )

Interviewer was quite younger than me. He asked me to write a program using a singly linked list where he wants to remove Nth element counting from last node you added. e.g if you added 10 elements in the list then 7th element from end is 4th element you added in beginning, hence 4th should be removed. If 1,2,3,4,5,6,7,8,9,10 are the elements you added then “./a.out 7” should remove 4 not 7.

I told him I can use singly list as stack where elements are always added in reverse order. From his looks I could make out he could not understand what I just said. So I asked him if can I use any method,he replied that I should use pointers and gave  a paper and pen to write. This is the full-fledged code with all the checks and added command-line input and string conversion etc. but algorithm/logic/data is exactly same I wrote there and he said this code will not remove 7th from end but 5th from end.   This is wrong code. I was shocked to hear that. Loot at it yourself and see the output:

/* HCL Interview Question (2017)
 *
 * A singly-linked-list (SLL) program to add nodes to SLL and remove Nth node
 * from the end
 *
 * e.g Add 10 nodes to a SLL & remove the 7th node starting from the end
 * 7th node from end is 4th node you added while building SLL
 *
 * I am using a Stack (LIFO). Last node (the end) is always the latest. So, we can
 * go down from there easily. The interviewer said it will not work.
 * Worked fine for me 🙂
 *
 ***/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include 				<limits.h>

struct node {
  long nn;
  struct node* next;
};

struct StPtr {
  struct node* head;
  long tn; /* totoal number of nodes */
};

struct StPtr* st;

void print_diagnostics(void);
void printStack(void);
void convert_to_long(long*, long*, const char*, const char*);
void addNodes(long, long);
void removeNode(long, long);

int main(int argc, char* argv[]) {
  if(3 != argc) {
    print_diagnostics();
    return EXIT_FAILURE;
  }

  st = malloc(sizeof*st);
  if(NULL == st) {
    printf("Out of Memory\n");
    return EXIT_FAILURE;
  }

  st->head = NULL;
st->tn = 0;
  long t = 0, r = 0;
  convert_to_long(&t, &r, argv[1], argv[2]);
  addNodes(t,r);
  printStack();
  removeNode(t, r);
  printStack();  

  return EXIT_SUCCESS;
}

void removeNode(long num, long rem) {
  if((0 >= num) || (0 >= rem) || (rem > num)){
    printf("Nothing to remove\n");
  }
  else {
    struct node* t = st->head;
    struct node* prev = st->head;
    long i = (t->nn - rem) + 1;
    /* IF we ar eremoving the head */
    if(i == st->head->nn) {
      st->head = st->head->next;
      st->tn--;
      printf("Removing node#: %ld \n", i);
      free(t);
    }
    else {
      while(i != t->nn) {
	prev = t;
	t = t->next;
      }
      prev->next = t->next;
      printf("Removing node#: %ld \n", i);
      st->tn--;
      free(t);
    }
  }
}

void addNodes(long num, long rem) {
  if((0 >= num) || (0 >= rem) || (rem > num)){
    printf("Nothing to add\n");
  }
  else {
    for(long i = 1; num >= i; ++i) {

      struct node* p = malloc(1 * (sizeof *p));
      if(NULL == p) {
	printf("Out of memory, will not add node\n");
      }
      else if(NULL == st->head) {
	printf("Adding 1st node\n");
	p->nn = i;
	p->next = NULL;
	st->head = p;
	st->tn++;
      }
      else {
	p->nn = i;
	p->next = st->head;
	st->head = p;
	st->tn++;
      }

    }
  }
}

void convert_to_long(long* num, long* rem, const char* numptr, const char* remptr) {
  errno = 0;  /* To distinguish success/failure after call */
  char* endptr;
  long temp = strtol(numptr, &endptr, 0);
  if( ((0 == temp) && (0 == strcmp(numptr, endptr)) && (errno == ERANGE))
      || ((LONG_MAX == temp) && (ERANGE == errno)) ) {
    *num = 0;
    *rem = 0;
  }
  else {
    *num = temp;
    temp = strtol(remptr, NULL, 0);
    if( ((0 == temp) || (LONG_MAX == temp)) && (ERANGE == errno) ) {
    *num = 0;
    *rem = 0;
    }
    else { *rem = temp; }
  }
}

void print_diagnostics(void) {
  printf("Invalid Number of Args\n");
  printf("Provide 2 arguments:\n");
  printf("\t1st arg is number of nodes\n\t2nd arg is nuber of node to be removed\n");
}

void printStack(){
  struct node* t = st->head;
  for(t = st->head; t; t = t->next) {
    printf("%ld, ", t->nn);
  }
  printf("\n\t---> Total %ld nodes\n", st->tn);
  printf("\n======================================\n\n\n");
}

OUTPUT:
[arnuld@arch64 programs]$ gcc -std=c99 -pedantic -Wall -Wextra ll.c
[arnuld@arch64 programs]$ ./a.out 10 7
Adding 1st node
10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
—> Total 10 nodes

======================================

Removing node#: 4
10, 9, 8, 7, 6, 5, 3, 2, 1,
—> Total 9 nodes

======================================

[arnuld@arch64 programs]$ ./a.out 10 5
Adding 1st node
10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
—> Total 10 nodes

======================================

Removing node#: 6
10, 9, 8, 7, 5, 4, 3, 2, 1,
—> Total 9 nodes

======================================

[arnuld@arch64 programs]$ ./a.out 10 1
Adding 1st node
10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
—> Total 10 nodes

======================================

Removing node#: 10
9, 8, 7, 6, 5, 4, 3, 2, 1,
—> Total 9 nodes

======================================

[arnuld@arch64 programs]$ ./a.out 1 10
Nothing to add

—> Total 0 nodes

======================================

Nothing to remove

—> Total 0 nodes

======================================

[arnuld@arch64 programs]$

I don’t understand how could he say this code will not remove the Nth node from end , code behaves fine. May be he never wrote a Stack in his life. I did another mistake by trying to explain him that Stack is an implementation of a linked list and he shrugged it off. He asked me to write it using some other method (he meant another algorithm) but explain to him first and I did and he said same words again that this new method will not work either. Then I told him, there are several ways you can approach the problem that is why so many algorithms (methods 😉 ) exist and is there any specific method he is thinking of ?   He told me that he is done with me and I can leave for the day  🙂

After coming out I saw on the doors in capital letters, “ODC” was written. That means Offshore Development Center. Most of the ODCs in Indian companies are service based, there is not much development/coding involved. Companies in India, get freshers in a mass based campaigns from colleges and put them on work because they are dirt cheap to get when it comes to economy. These freshers have never worked before and most of engineering colleges here have non-ISO conforming compilers and code in their CS textbooks too does not conform to any ISO/ANSI standard. They have learned C and C++ using such resources, so it is expected that they wont know what is the definition of C language and how do ISO conforming compilers and non-forming compilers behave and what it costs in terms of bugs and maintenance.

Now lets get back to HCL, the company. What did they lose ?  I am just one programmer and what about others. There were 100 people for interview and I am sure at least 10 of them must be very good programmers. Will they get hired ?  I have been to interviews where I had to choose one answer out of 4 options given to me for   “int i = 0; prinf(“%d\n”, i++ + ++i)” and none of the options said “UB”. You were forced to choose an integer as an answer. What did I do ? I wrote “option5: UB” just below tho option 4 and of course I was not hired 🙂 . Can you imagine the quality of code in such a company, quality of hires ?   and what a nightmare it will be to fix bugs and add new features ?  HCL did not do much different from them in my interview. Whom to blame ?  Their hiring process which lets a person with low knowledge of Data-Structures interview a person with medium level of knowledge of Data-Structures. Who created such process. I know I am not that intelligent  because I have never written an AVL Tree and I can’t understand more than half of Maths Knuth writes in his Art of Computer Programming books. I just try to improve everyday and like to read definition of language, reference manuals and man pages and do what they advise. And I am still working on Knuth. In book Programming Interviews Exposed authors wrote that the more you stay away from coding and move towards business side, the more money you make and more secure your career will be (I did not know at that time that google’s machine learning department is working on making coding obsolete).  You make more money if you move from being programmer to business analyst and to software architect (A glassdoor search will tell you that it is really true). Now, how does a person who loves to program, who loves  to write code day and night, who loves to learn more languages, algorithms, more UNIX, Linux, DragonFlyBSD, NetBSD and more UNIX way of solving problems, data-structures, gcc libraries and learn more about programming paradigms,  loves Lisp and the idea behind its macros, loves to read why Eiffel was created and what problems it solves and why and how does it do it and wants to inculcate these as a part of his thinking, plus the shell he works in, and then mastering his text-editor etc. All that  just for the interest and liking. What that person can do to show his skill and get to work with MNC ? Not much if company is not even interested in having a skilled person and improving their software, tools and methodologies.  I think that challenge comes down to the programmer himself. Few companies want to improve, most don’t and you go and find those few companies.

Copyright © 2017 Arnuld Uttre, Hyderabd, Telangana – 500017 (INDIA)
Licensed Under Attribution-NoDerivs 3.0 United States (CC BY-ND 3.0 US)

Death of comp.object

January 16, 2015 at 10:40 am | Posted in Programming | Leave a comment
Tags: , , , , ,

If you are passionate about programming then you must have discussed about programming on some Newsgroup. It is really sad to see that current generation of programmers have never heard of something called USENET or a Newsgroup. Even programmers with half a decade of experience in OOP have never heard of comp.object and this is exactly the place where I learned the foundations of Object-Oriented methodology. As of 2015, comp.object is dead and full of spam, almost no useful post from couple of years, useful in the sense where some experienced OO practitioners have discussed something very fundamental and basic related to the OO Methodology. There were people like H.S.Lahman, Uncle Bob, Daniel T, Jerry Coffin, Philip and S. Perryman (and of course never forget anti-OO-zealot “topmind”). There were several others but I can only recall back few.

To tell you the truth, I never hates OOP as much as “topmind” hates OOP, I hated the very word “object” but that all changed when I started hanging on comp.object. I made very few posts and all of them were a newbie asking the answers to his questions and doubts but I read a lot of posts, really hell of a lot of threads I read and just like comp.lang.c, comp.lang.c++, comp.lang.lisp it was a very good experience in following the guidance of the folks there. Here is some brilliant advice on how to start learning OO way from one of the experts in the field (H.S.Lahman), I have not edited his advice, do not want anyone to miss his original words :), here are the abbreviations to some of the acronyms:

  • OT: Object Technology (referring to the entire field based on Object Oriented Thinking)
  • OOA: Object Oriented Analysis
  • OOD: Object Oriented Design
  • OOM:Object Oriented Modelling

> I am new to the field. I have some programming experience. I
> was wondering if anyone could recommend a good book to start.
> Thanks in advance.

Alas, OT is a big field and one book probably won’t do it for you.

I would suggest you start with a book on OOA and/or OOD. Such books
generally describe the fundamentals better. But avoid books with a
specific language or ‘UML’ in the title. Those tend to be about
manipulating syntax rather than fundamentals.

Even if you end up using a pure OOP-based process, you should still
trying some UML modeling. That’s because it provides a good expression
of the fundamentals in a very compact manner. In this case a book with
UML in the title is an advantage.

Then you need to deal with OOP. For that you need a book with a
specific language in the title. Probably two books because it is useful
to start “playing” with OT using a “purist” language like Smalltalk.
That will complete the OOA -> OOD -> OOP cycle in the most coherent
fashion. (Alas, the most popular OOPLs have made more compromises with
Turing so the transition is less obvious.) Then you will need a book on
the language de jour if you plan on doing OT professionally.

You’ll notice I didn’t recommend any specific books. In each category
there are lots and most are pretty similar. Since I haven’t read them
all, I can’t even guess which one is actually the best. Just browse
them in a book store and pick the one that seems most readable and
provides the most clarity to you.


There is nothing wrong with me that could
not be cured by a capful of Drano.

H. S. Lahman
h…@pathfindermda.com
Pathfinder Solutions
http://www.pathfindermda.com
blog: http://pathfinderpeople.blogs.com/hslahman
“Model-Based Translation: The Next Step in Agile Development”. Email
in…@pathfindermda.com for your copy.
Pathfinder is hiring:
http://www.pathfindermda.com/about_us/careers_pos3.php.
(888)OOA-PATH

Such a beautiful explanation, so straightforward and simple advice. If you search the archives of comp.object on net then you will come across much larger information from many intelligent and experienced people. I did read lot of threads and based on that knowledge of mine I started searching more about it and came across few interesting facts and one of them is: OOP is not really about objects . Is that shocking ? You think I must be crazy to suggest that Object Oriented Programming is not about Objects. The only important building-blocks of OOP are two: one is old and other is modern. As per Old thingy, poor Alan Kay, the man who created OOP, OOP is not about objects and in facts Alan Kay regretted using the word “object”. It is about message-passing. As per the modern outlook, OOP is about how objects behave , not how they are constructed or what features they have. Inheritance or Classes are not basic building blocks of OOP.

Proof ?

Self is a Class-less OO language :). One does not need Classes or Inheritance to do OOP. It is so much interesting. Now I understood that I really did not hate OOP, I hated the way it is taught in schools/colleges, same way all students hate Math, not because Math is boring but because it is taught neither in a right way with basics nor in its practical applications to this world. subjects/Fields which are so interesting in this practical world are never ever taught in schools that way. Not only that, 2nd reason I hated OOP is, even in professional world most software engineers never ever learn beyond what they learned back in college. A student who just got out of college looks upon experienced professionals as his gurus, his new teachers who will guide him to correct path but that does not happen much. Good programmers are rare and half of them are jobless. First, generally people are lazy and 2nd the ones who are not lazy, do not get time to learn more and 3rd, not everyone likes programming, and if you belong to lazy or no-interest group then that means you should not be doing programming. Programming is about passion, without passion and interest you will never ever going to be good at it. Without interest I could never have found what Alan Kay said about OOP and I could have never come across the modern definition of an Object. I checked comp.object after several years today and what I see, comp.object is a dead group. It was sad to see no new threads on OO methodology from the the time I stopped reading. I wanted to ask what happened and in archives I see someone already asked same question and the answer to that was true but a sad one: world has changed , it is digital age, this tech world moves very fast compared to other domains like sales for example and OO landscape is no longer the same. comp.object is full of spam now, its is dead and gone, here are the reasons why it happened, think of this blogpost as a record of the history, it is difficult to find USENET Newsgroup archives these days. You can try searching it on google groups, original thread title was “OOP, this NG and you. Where is everyone?” and I have posted a link at the bottom. Tis question was posted by Alvin Ryder:

HI Guys,

A few years ago this was a pretty active NG, it seems to be rather
quiet now and I seriously wonder why?

Is it because:
a. Uncle Bob rarely visits?
b. No one programs in English speaking countries anymore?
c. No one uses OOP much anymore?
d. Everyone moved to a funkier group? If so which one?

I don’t have any real clue what do you guys think (erh, if anyone sees
this)?

Cheers

[by Alvin Ryder]
—————————————————————————

Usenet in general has been on the decline for the past several years,
probably because of the rise of Web based forums. I think that’s part of it.
In addition, some/many of the regulars seemed to have moved on. Also, and
this is nothing personal, I would contend that the activity of this group
over the past 8 years has been somewhat artificially inflated due to
topmind’s involvment. If you do searches on this group regarding a variety
of topics, you’ll run across many monster threads circa 5 or 6 years ago
involving the regs and topmind. As far as OOP in general, maybe it’s reached
the point in which every thing that can be said has been said.

[by Leslie Sanford]

———————————————————————————-

> “Leslie Sanford” wrote:

> Usenet in general has been on the decline for the past several years,
> probably because of the rise of Web based forums. I think that’s part of it.

Sadly. Blogs seem to be taking usenets place.

> In addition, some/many of the regulars seemed to have moved on.
> Also, and this is nothing personal, I would contend that the
> activity of this group over the past 8 years has been somewhat
> artificially inflated due to topmind’s involvment. If you do
> searches on this group regarding a variety of topics, you’ll
> run across many monster threads circa 5 or 6 years ago
> involving the regs and topmind. As far as OOP in general, maybe
> it’s reached the point in which every thing that can be said has
> been said.

Agreed on the later point. OO seems to have reached some sort of
saturation point. The time is getting ripe for the “next big thing”, but
it seems that thing still hasn’t shown its face.

[by Daniel T.]
—————————————————————————————-

> Responding to Ryder…
> A few years ago this was a pretty active NG, it seems to be rather
> quiet now and I seriously wonder why?

I agree with Sanford. I would add that a surprising number of
developers today don’t even know that USENET exists.

However, I would also add the militant proselytizing of the OOP-based
agile crowd. That definitely killed the old OTUG forum Rational ran —
which was busier than comp.object once upon a time — and I think it
contributed here as well.

[by H.S.Lahman]
—————————————————————————————–

> “H. S. Lahman” wrote in message
> I agree with Sanford. I would add that a surprising number
> of developers today don’t even know that USENET exists.

> However, I would also add the militant proselytizing of the OOP-based
> agile crowd. That definitely killed the old OTUG forum Rational ran —
> which was busier than comp.object once upon a time — and I think it
> contributed here as well.

Contributed how ??
I doubt said “crowd” drove anyone away en-masse from the comp.* groups.

OTOH, a lot of them certainly seemed to exit stage left when their claims
were challenged sufficiently often (like giving it but not taking it etc) .

Regards,
Steven Perryman

——————————————————————————————

> Responding to Perryman…
>> However, I would also add the militant proselytizing of the OOP-based
>> agile crowd. That definitely killed the old OTUG forum Rational ran —
>> which was busier than comp.object once upon a time — and I think it
>> contributed here as well.
>
> Contributed how ??
> I doubt said “crowd” drove anyone away en-masse from the comp.* groups.

Bandwidth. Not too long ago this group generated ~100 messages a day,
which takes awhile to sort through. When a lot of those messages are
about advocating a particular development process and have little to do
with the thread subject matter, people decide they just don’t have time
to sort through it all. [On OTUG people were quite specific about why
they were quitting and there was no equivalent of Topmind pulling
people’s chains. The agile crowd learned from that and aren’t as
obnoxious here, but the basic bandwidth problem remains.]

When the fraction of that 100 messages/day that are feeding the P/R
troll or are about OOP-based agile advocacy approach 50% or so, the
useful information content of the forum becomes greatly diminished and
it ceases to be worth the trouble to sort it out. (Putting people in
kill files doesn’t work well because occasionally they have something
useful to say and it also trashes the context of the messages responding
to them.)

[by H.S.Lahman]
—————————————————————————————–

I’ve learnt more from this NG about software development than any
other single source, but after a while people just sit in the same old
entrenched position (myself probably included), noone ever admits to
having learnt anything new, or being wrong, so it fails to become a
positive experience, it’s just another endless avalanche of ranting
and nay saying….(myself probably included).

[by Mark Nicholls ]

——————————————————————————————

> Responding to Parker…

> I don’t know. “Object Oriented” as a tag line has been vanishing for
> some time. It wouldn’t help you to publish a book anymore to have OO
> in the title. I don’t see any conferences anymore with OO in the
> name. Vendors have long since stopped talking about OO. All the so-
> called OO “methodologies, the Shlaer and Mellor, the Booch etc. appear
> to be gone, and no one seems to miss them. The OO databases are
> largely gone, no one talks about OO operating systems anymore.
> “Executable UML” is mostly gone. OO was part of one giant hype cycle
> for a while, but it’s over, and now the hype has moved onto other
> things, today it’s SOA. And just like not all of the SOA hype is
> nonsense, only 90 percent, not all of the OO hype was nonsence
> either. We still have the programming languages with support for
> ADTs. But that’s about it.

I agree there is a lot less marketing hype about OO, but why is that?
How many shops outside of low-level R-T/E and RAD pipeline development
use an OOPL vs. a procedural language or FPL? The reason there isn’t any
hype about OO is because it has been broadly accepted so talking about
it has no direct marketing value. In the early ’80s how many people were
selling tools because they were procedural? They were all procedural so
there was no point in differentiating on that basis.

In addition, if one looks at the technologies de jour that are being
hyped today, like SOA, they are mostly enabled by OO techniques. Even
the most hard-core RAD DBMS tools are climbing all over themselves to
look more OO-like.

I agree OOA/D methodologies are currently on the wane temporarily
because the OOP-based agile crowd is trying to convince everyone that
all you need to know about is OOP. But that bubble is beginning to burst
and I expect OOA/D methodologies to rebound, especially because…

As far as executable UML is concerned, it has “gone” to the major
commercial software houses. There are only two translation vendors from
the ’90s that are still independent as the big houses position
themselves strategically. The 50+% productivity and reliability gains
make translation as inevitable as conversion from BAL to 3GLs was. So
translation isn’t going anywhere; everyone else will be coming to it.

> comp.object became a “soft”
> newsgroup where almost anybody could post how they felt about “getters
> versus setters” or “method versus message”, or “behaviour versus
> data”, or “tell versus ask”. We were told there was theory, but it
> was somewhere else, in a book by Abadi and Cardelli or in some paper,
> but it never seemed to get incorporated into any discussions.

But aren’t those issues fundamental to OOA/D? Don’t the justifications
of those positions represent OO methodological theory?

Unfortunately one problem with comp.object is its schizophrenia. It
combines OOA, OOD, and OOP, which are quite different things. Thus the
type theory of A&D is largely irrelevant to OOA/D discussions while OO
design issues like separation of message and method are irrelevant to
OOP. IMO far too much forum bandwidth was spent on OOP issues. There are
plenty of language and programming forums on USENET where code
refactoring discussions could live. But comp.object is one of the few
software design forums.

[by H.S.Lahman]

original thread made available by Google through Google Groups Web interface.

Copyright © 2015 Arnuld Uttre, Hyderabd, Telangana – 500017 (INDIA)
Licensed Under Creative Commons Attribution-NoDerivs 3.0 license (a.k.a. CC BY-ND)

Next Page »

Blog at WordPress.com.
Entries and comments feeds.