Jul 242004

how to become a software architect

Every large software system needs an architect. Although many people clamor to become architects, there is still a lack of qualified architects in the industry. In this article, I will list what I believe to be the essential characteristics of an architect. It is relevant for senior developers and junior architects.
[On setting high standards…] Two things emanate from this changed standard. First, the work becomes more fun. It is deeper, it never gets tiresome or boring, because one can never really attain this standard. One’s work becomes a lifelong work, and one keeps trying and trying. So it becomes very fulfilling, to live in the light of a goal like this. But secondly, it does change what people are trying to do. It takes away from them the everyday, lower-level aspiration that is purely technical in nature, (and which we have come to accept) and replaces it with something deep, which will make a real difference to all of us that inhabit the earth. — Christopher Alexander


During the course of my research I was amazed to learn that all the software that controls the aircraft traffic was written by just a few individuals using fewer code than an average website today. That the code stood for so many years is a testimony not to the static requirements, but to maturity of the programmers.

At one time, programming was only for the elite. Programs were written only by smart individuals, perhaps well versed with algebraic notations of mathematics (no wonder that most programs in those days borrowed those notations). Their programs were limited in scope, simple in integration, and cohesive in planning.

Times change. These days, the range of tasks that computers are expected to do are lot more diverse than before. They are expected to work well with other systems and need to be supported and maintained long after they are designed.

However, the average programmer today is less qualified to write code than before.

Sure, programming has become easier — it takes a few click and select operations to generate a GUI that used to take better part of a week. Advances in basic computer science are good enough to produce a decent quality parser within hours, instead of months.The “Code, compile, debug cycle” is shorter than what it was before. In short, it takes less “smarts” to write code than before.But, has programming become simpler? Coding may have become less difficult, but designing the system is as complex as before, if not more. Confusing array of technologies, competing choices of platforms, increasing needs to integrate applications — all these factors made software architecture more demanding than ever.

My thesis is this: An architect is not just an experienced programmer; he is a programmer with a special mindset. It is a qualitative jump from being a programmer. In this essay, I will write down what I believe to be the needed qualities in an architect, in particular, a J2EE architect. (I use the term architect for software architect exclusively throughout this note).

What is an architect?

I often get resumes with architect in title. Judging by these resumes, an architect is supposed to have the following qualities:

  1. Knowledge of UML
  2. Being able to draw architecture diagrams
  3. Experience as a developer

Architect: Someone who knows the difference between that which could be done and that which should be done. — Larry McVoy

The predominant thought seems to be progrmmers with long years of experience in coding either become managers or architects. Typically, all the people with an interest in technology become architects. But, what is the role of an architect in software development?

  1. Defining the problem in technical terms: Normally, the problem is stated in the terms of the domain — it could be scientific, business, or any other area where the solution is needed. To solve that problem using the computer, you must be able to state the problem in “computerese”, which means, in the terms of established technical frameworks. Typically, it takes:
    1. Understanding the problem as explained by the customers
    2. Translating into the computer solution domain
    3. Guiding the customer to well understood problem-solution patterns, and
    4. Understanding where true innovation is required
  2. Specifying the technologies needed: A given problem can be solved with diverse combinations of technologies. It is the architect’s job to specify what technologies to be used.
  3. Defining the major modules of the system: The architect also must break down the system into modules and define interactions between modules. In fact, she should also specify the guidelines of interactions so that the module dependencies are well understood.
  4. Recommending patterns and frameworks: Since there is nothing new under the sun, each problem, in some fashion must have been solved earlier. It is the architect that should identify the relevant previous patterns to apply in the current project. In addition, she may need to define new patterns to be used in the application.
  5. Establishing code quality measures: For example, code reviews and design reviews fall under the code quality measures. The architect should establish the guidelines and practices in the team.
  6. Establishing Best Practices: Any given task can be done in many ways, some of which are equally good. However, an architect must establish best practices for doing even these mundane tasks so that consistency is maintained, and unnecessary effort is spared in looking for solutions.
  7. Maintaining conceptual integrity of the application: As the project grows, requirements change; new technologies get added; new people come into the project. With all these changes, it becomes imperative to maintain a coherent and consistent vision of the project. An architect should be able to do that.

With these duties in mind, I am going to list the characteristics of a successful architect.

Personality traits

To be successful architect, you must have the following traits:

  1. You should be passionate: Go back to the quote by Christopher Alexander in the beginning of this note. As it said, as long you are doing a job, you should try to do it as best as anybody else in the world can do it. Your pride and passion in your work makes you the strongest critic of your own work.
  2. You should be inquisitive: In these days, there are far too many new developments in the technological front. Unless you are naturally curious, you may miss the right tools for the job. If you do not try these tools by yourself, you will end up taking recommendations from others, worse — from the vendors.
  3. You should be skeptical: In the era of hype and buzzwords, it takes a special talent to remain inquisitive, passionate and yet the same time skeptical about the technical advances. Understanding the history of software provides a good dose of reality, enough to make anybody a skeptic.
  4. You should be honest: It takes intellectual honesty to acknowledge one’s shortcomings and learn. It also helps in serving the customers and your colleagues better.
  5. You should be courageous: Without courage to speak out and confidence to make recommendations, you will never be able to make a difference in the state of the world, especially, in the world of software.
  6. You should be compassionate: Unless you understand the impact of your actions you will not make the correct technical choices. It is easy to lose sight of the impact on people when working with machines. As an architect, the choices you make will effect not only you, but also your colleagues and customers, not only now but also even in future.
  7. You should be quality conscious: Quality of a work reflects in the details. Paying attention to even the smallest details and balancing them with the realities of the project is the hallmark of a true architect.
  8. You should be ready to convince others: As an architect, you should be able to convince your team members, managers, and clients of your vision. It means having the patience to explain to the outsiders, the interest to mentor the junior team members, and the humility to listen and learn from others.
  9. Above all else, you should have good taste: Good taste, while being subjective, is easy to recognize. An architect should develop good taste that leads to consistency of vision, simplicity of design, and cleanliness of implementation.

Technical Experience

It takes experience to become an architect. This sort of experience cannot be counted in the number of years, but in the amount of wisdom gained from it. If you want to become an architect, you should try to acquire and master these skills.

  1. You must know the basics of computers: There are several aspects to the basics of working with a computer. These basics will help you understand the nature of solutions that people are used to. It lets you anchor your ideas with familiar simple patterns.
    1. You should master at least one OS: I prefer people to master one version of Unix (or Linux) for it encourages people to explore “under the hood”. However, any OS will do for this purpose. To truly master an OS, you should be able to install, maintain, manage, and make it do whatever you want to do.
    2. You should master at least one scripting language: Turns out that most of the time, we manipulate text, whether we are writing code, generating code, generating data, analyzing test results, or preparing reports. A scripting language that lets you do these tasks efficiently will make you effective.
    3. You should master at least one High Level Language: It goes without saying that at least one main stream HLL (C++, Java, C#, C) is absolutely essential. Of course, it is even better if you know languages like LISP, to understand the possibilities of language design.
  2. You should master the tools of trade: Since you work with these tools no matter what you do, mastering them makes you efficient. Be sure to choose the tools that are ubiquitous or that you can carry with you.
    1. You should master at least one editor: Since editor is the most used program, mastering it is essential for an architect. I use Emacs, but any editor with extensibility and macros will do.
    2. You should master at least one document producing system: Producing well-written, informative, and aesthetically pleasing documents is a needed skill for an architect. The most popular tools to develop such documentation is MS Office. Several Open Source proponents use SGML/HTML/XML. LaTeX, TeX is the most used system in Academia. The market you are pursuing may best dictate your choice.
  3. You should understand the basics of computer science: Many people learn programming on street corners. While the practice of programming is just that — practice, it can benefit from good understanding of basics of computer science. For example, I find myself using the data driven abstractions in all my designs.
    1. You should understand data models: Most computer programs are concerned with collecting, classifying, managing, and presenting data. As such, understanding data models, schemas, and databases is an important part of an architect’s portfolio.
    2. You should understand transactions: There are far too many myths associated with transactions. An architect understands where transactions are needed, where they are superfluous, and where they can be simulated in programs and in databases.
    3. You should understand three fundamental Programming Constructs: All programs are built up using the same techniques: combination of the basic blocks, abstraction to create new building blocks, and application of these abstractions. Understanding and practicing these fundamental techniques in proofs, code, or documents is an experience that an architect should have.
    4. You should understand higher-order functions, and data-driven abstractions:
      “Any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp.” – Phil Greenspun

      One of the original models of programming languages, lambda calculus has no data; instead it is represented as functions. These days, it is common to abstract programs as declarative data, particularly in programs where flexibility is desired. A proper understanding of these abstractions is necessary for an architect to create good architectural patterns.

  4. You should learn the craft of programming and managing software through practice: Any architect should write code. Without writing code, they cannot meaningfully design the system. In fact, through this practice they should learn a few things:
    1. You should have, through practice, a set of preferred solutions that you thoroughly understand: A friend of mine has several standard templates for solving the problems with the tools that he knows well. For example, he could put together any workflow automation with email and procmail. Philip Greenspun used AOL Server, TCL, and Oracle to solve his problems. Joel Splosky uses Excel to solve his problems. Basically, you need to develop trusted frameworks that can help you solve your problems. Since you practiced these technologies already, you would not waste time in interoperability issues; more over, you would have evolved best practices in these frameworks.
      One aspect of these technologies is that they enable you to develop quick prototypes. Often as an architect, you need to prototype to validate some ideas. Having a least expensive way of prototyping a realistic application can help you make the right choices.
    2. You should understand abstractions for standard problems: Using patterns is an effective way to capture trusted solutions for most common problems. However, patterns are too concrete to capture several problems. There are standard abstractions that any architect must be familiar with. A partial list includes:
      1. Use of caching: Caching occurs in all ORM solutions, and in any solution where you keep data in multiple places. There are standard solutions with different characteristics — real time coherence, delayed coherence, and on-demand coherence.
      2. Use of views: Most problems are concerned with maintaining different views of data. Even the MVC paradigm is about presenting a different view of the data. Most of the data analysis packages present different views of data.
      3. Use of declarative extensions: To extend a static program, there are different strategies ranging from command line options to dynamically loading extensions to XML based configuration files. Some systems provide scripting extensions.
    3. You should understand the standard software development practices: A partial list includes
      1. programming life cycles — XP practices, Waterfall methods, RUP,
      2. requirements writing,
      3. version control,
      4. development environment configuration,
      5. logging,
      6. debugging,
      7. documentation,
      8. building process,
      9. testing process,
      10. release process, and
      11. bug tracking process.
  5. You should learn to work with a team: Since your decisions as an architect impact the whole team, you should learn to work with the team. I am not going to list out the rudiments of team play, but I would like to point out the technical skills required:
    1. You should be able to write well:
      “Programs must be written for people to read, and only incidentally for machines to execute.” — Abelson & Sussman, SICP.

      Most programmers communicate more with people than machines during the course of a project. In fact, even writing programs is predominantly to communicate with people. It is no wonder that for an architect, being able to write well is one of the most fundamental necessities.

    2. You should practice good communication mechanisms: Since most of the knowledge about building a system is captured in conversations, it is imperative that architects should have good understanding of the mechanisms for fostering and developing those communications. For example, understanding on how to set up project portals, how to publish code reviews, code metrics results, how to encourage mails to mailing lists — all these activities help reduce the learning curve for a new member.
    3. You should make work interesting: As it is, working with computers can get boring, unless you can make the work interesting. You should encourage junior members to learn and experiment so that they can gain from experience. For example, you could motivate them by offering a chance to do the following:
      1. learn new technologies,
      2. apply best practices,
      3. learn and documenting patterns and frameworks, and
      4. learn good development principles.
    4. You should be available for the whole project life cycle: Unless you are ready to accept the consequences of your choices, you should not make architectural decisions. You make sane choices only if you are forced to think about how a technology is used by the developers and how it is supported by the vendors or community, and how it can be upgraded to support new advances in the other technologies and protocols.

J2EE Knowledge

That’s one sure tip-off to the fact that you’re being assaulted by an Architecture Astronaut: the incredible amount of bombast; the heroic, utopian grandiloquence; the boastfulness; the complete lack of reality. And people buy it! The business press goes wild! — Joel Splosky.

Several people wanted to know about what makes an effective J2EE architect. In my opinion, there is nothing significantly different from a J2EE architect and a regular software architect. I am going to take ideas expressed in the preceding sections, and concretize them. That is, wherever possible, I will make specific recommendations.

  1. Learn the basics: If you are a J2EE architect, it makes sense to understand the basics behind Java, JVM, and J2EE. That is to say that you should both read the API documentation and experiment with the fundamentals.
    1. You should understand the performance characteristics of Java: Quick! How many objects can you generate per second in Java? How many characters can you read per second? How many can you write? How many JDBC calls can you make? All these questions do not have definite answers; they depend on several factors, some of which are not in the control of the programmer. However, knowing these answers for any representational system will let an architect make rational choices.
    2. You should understand the basics of JVM: For example, what options does it take? Can you share code between two JVMs? How do you control class loading? How do you do introspection? How do you write JNI? For all these answers, you must have experimented with your own code so that you understand the rationale behind Java language design choices.
    3. You should understand the basics of garbage collection: How do you control, measure, and manipulate memory in Java? How do you track memory management in JNI? How do application servers deal with memory management? You should learn the native diagnostic tools of Java and JVM so that you can debug memory issues in Java.
    4. You should know HTML, HTTP, CSS, and Javascript: Ultimately, we deliver html to the browser using HTTP protocol. Several senior developers consider these technologies to be beneath them; after all, either the tools or the designers hide them from the developers. However, these skills can make an architect develop good usable solutions.
  2. Master the tools of the trade: There are several tools used to help with Java development, most of them are open source.
    1. Development Environment: Proper configuration of an IDE/Development and testing environment is essential for productivity gains. In addition, by standardizing it, you can improve the process of inducting a new developer into the team.I recommend a good open source IDE like Eclipse. It comes well equipped with several plugins that are useful for various purposes. For example, it has facilities for the following:
      1. It lets you create your own templates for Java files and classes.
      2. It supports integration with indenting engines like Jalopy.
      3. It supports integration with style checkers like Checkstyle.
      4. It is well integrated with CVS (supports cvs over ssh!) — with diffs, annotations, synchronizations, cvs ignores, and options to create new projects in cvs.
      5. It supports DB browsing as well.
      6. It has a plugin to add Logging automatically.
      7. It supports profiling an application so that you can improve performance.
    2. Build and test environment: To do builds and automated tests, you should learn the following tools:
      1. Build templates for automated builds. Choices are ant and maven.
      2. Unit tests with junit.
      3. Web test automations with either openSTA or curl.
  3. Practice the craft:
    1. You should master at least one end-to-end technology set that solves most problems: For example, you can master the combination: Oracle + Hibernate + Struts + Tomcat + Tiles + JSP. Whichever one you take, make sure that the following hold:
      1. The technologies must be well integrated to support a full solution.
      2. They must be easy to install and configure, so that they can be used for quick prototypes.
      3. They must scale to small to medium projects with minimal modifications.
      4. They must follow standards, so that the solutions can easily be transported to another similar solutions.
    2. You should develop best practices: Since Java allows for several different ways to express the same thought, and there are several competing ways to handle patterns, you should develop the best practices. In particular:
      1. Logging: You should know logging well. You should understand how to setup logging guidelines for the whole project.
      2. Exception Handling: You should know and understand the role of exceptions in a project. You should create the right exception hierarchy for the project.
      3. Style: You should establish a standard style for the project. You should understand the repercussions of violating the style guidelines and be able to convince the team.
      4. Coding Templates: Java encourages people to use several small files. By establishing the right templates for class files you can increase maintainability of the code. For example, by adding proper keywords, you can have the version information from the version control mechanism itself. By adding the right javadoc comments, you can eliminate long and verbose changelog, which belongs in the version control.
    3. You must practice continuous refactoring: While refactoring is important for any software project, good tools make it feasible for a Java project. You should understand the role of software metrics in maintaining software. You should know how to write code at a domain level, instead of language level. You should know how to establish practices for naming, abstraction, and application of the code.
    4. You must know at least one code generation technique: Unlike Lisp, Java does not treat code manipulation as a first class activity in the language. However, all the Java based systems such as containers do generate code. Many templating systems generate code. Code generation is becoming even more popular with Aspects. Therefore, for an architect, learning some code generation techniques are important.
  4. Foster Teamwork: Java and its tools make it easy to foster good teamwork. For example, Eclipse has plugins to access most version control systems. The following tools and practices can help a team communicate well.
    1. Version Control: A properly configured CVS can help a team manage its source code well without clobbering changes made by others. In addition, it can show who is responsible for what change. Such tracking ability makes developers more responsive towards unit testing and documenting the changes. Moreover, Eclipse has good support for CVS.
    2. Project Information Systems: The Java world has tools that support automated building of project portals so that project can be tracked by mangers and clients. In addition, these portals can help a new developer understand the project better. The two leading choices are: maven and Forrest.
    3. Automated Code Quality Measures: These tools can help a team communicate well using the code. For example, code that has good code metrics is easy to read and follow. There are good code metric tools integrated into eclipse.

You must become immune to hype: Even though this point has been said once before, it is worth repeating. In the Java world there is a tendency towards claiming solutions for “grand” problems that are difficult to solve. While the dynamic nature of Java has permitted the design of interesting toolkits, there are no silver bullets for the truly difficult problems. Whenever I read about any product or innovation in Java, I try to count ten reasons why it would not work.

Reading Material

  1. The Wizard Book: Generally acknowledged to be the best Computer Science book on programming, it is a tough read, not because it uses Scheme programming language, but in spite of it. Several concepts it introduces are essential to developing right abstractions in solution development.
  2. Ward’s Wiki: This mother of all wikis has collective wisdom of several developers and architects. From the well-informed and diverging opinions presented there, you can learn a lot about software development.
  3. Richard Gabriel’s Site: He is one of the Lisp gurus, and the author of an influential article called “worse is better“. In particular, his book on software patternsmakes an interesting read.
  4. Pragmatic Programmer’s Site: Even though the books are more appropriate for a senior software developer, they are useful to an architect as well. In particular, the eponymous book is a must read for any developer.

To understand the Java world better, there are several resources. Some of them are:

  1. resource: This site is an unofficial hang-out for several Java projects and weblogs.
  2. resource: All things related to application servers is discussed here.
  3. Apache resources: This site contains several packages available under ASF license, to be used in applications readily.
  4. IBM resources: This site contains several tutorials for a Java developer.
 Posted by at 4:51 pm
Jan 202004

Poetry and Prose — A prosaic view

[The oldpost …] Reminds me of “nuvvu lEvu, nee paaTa vundi”. I also
remember a trick that I was told by somebody back when I was in 8th grade and
trying my hand at poetry. Here is the simple recipe.

  1. First write what you want to write. It can be plain and simple. Let us start
    with a simple line like:

    “raatri cheekaTigaa vundi”. (రాత్రి చీకటిగా ఉంది)

  2. Now, if you have lot of lines like that, you can do a transpostional
    trasnformation as follows:

    “vundi raatri cheekaTigaa”. (ఉంది రాత్రి చీకటిగా)

    But, that transformation is not good enough on simple sentences. This is the
    mistake done by sophomore poets. So, we have to effect a few more
    transformations. Let us try one by one.

  3. First add the adjectives and similes. You can go towards two schools here.
    You can go towards “dEsa vaalee” or “puraaNa” style. To do the dEsa vaalee, you
    need to arm yourself with village vocabulary. Dredge up the teluguness. The
    farmer, the soil, the first rains, the shy girl, the jasmine, the village belles
    … these all are your friends now. If you decide to go the puraaNa style, it
    would be good to have some dictionary on hand, preferably like a thesaurus.
    (which I don’t, so we will skip those transformations now). So, let us add the

    raatri siggupaDutunna ammaayila, aspashTangaa, cheekaTigaa vundi.
    (రాత్రి సిగ్గుపడుతున్న అమ్మాయిలా, అస్పష్టంగా, చీకటిగా ఉంది)

  4. Now, make it a little difficult, like french consonents. Let us make the
    reader work at it. Let us drop the obvious.

    raatri siggupaDutoo cheekaTigaa vundi. (రాత్రి సిగ్గుపడుతూ చీకటిగా

  5. Now, we can go the extra mile, and make it into a “word picture”

    siggupaDutunna raatri
    mohammeedaki jaarina cheekaTi musugu.
    (సి్గ్గు పడుతున్న రాత్రి// మొహమ్మీదకి జారిన చీకటి ముసుగు)

  6. Here, consistency is important. Since we introduced the “shyness” motif in
    the first line, we are entitled to use the “musugu”.
  7. Or, if we go with the explicit route, the details are important. But, these
    details better be as detailed as possible. For example:

    “raatri cheekaTigaa vundi maa palErulaaga. (రాత్రి చీకటీగా ఉంది మా
    vaadi nalla kalla laaga merustunnayi aa mabbullonchi kanipinchE
    (వాడి నల్ల కళ్ల లాగ మెరుస్తున్నాయి ఆ మబ్బుల్లోంచి కనిపించే)
    naalugu chukkaloo
    (నాలుగు చుక్కలూ)
    keechu raaLLu vinchipustunnayi …. (కీచురాళ్ళు

    Here though, a juxtaposition with an
    abstract something is needed in the end. For example, you can end it with some
    message like:

    “eppuDo velugu raaka tappadu (ఎప్పుడో వెలుగు రాక తప్పదు)
    paaLEru nettuti lOnchi arunOdayam kaaka tappadu” (మా పాలేరు నెత్తుటి లోంచి
    అరుణోదయం కాక తప్పదు)

  8. If you go the earlier route of a little dash of ambiguity and impressionism,
    how do you end the poem? You got to keep the punch line that is either
    culmination of the same line of thought, or the opposite (sort of like judo
    punch). For example, the earlier motif of the word picture you can personalize
    by adding a message like: “naa gunDellO nee adugula chappuDu” (must … bring
    … night … motif; sorry no time). Or, you can throw a surrealistic fit too,
    if you want to:

    “kaavu kaavu mani koosE kaakula gOlatO tellarutundi” (కావు కావు మని
    కూసే కాకుల గోలతో తెల్లారుతోంది)

  9. But you see all these right? Why not go for broke, and try similes like that
    of “sEshEndra”? Here the trick is to use seemingly wrong adjectives. If you ever
    read any books about wine, you are ready for this task (shy boquet sort of
    things). So, let us try this:

    “raatri vagaru gaa vundi.” (రాత్రి వగరుగా ఉంది)

    Not good
    enough, right? But, throw in a few sanskrit words casually, and here is how it
    looks at the end:

    “raatri vagaru gaa vundi (రాత్రి వగరుగాఉంది)
    aandanaanni panchukunna prEyasi laaga,(ఊదారంగు ఆనందాన్ని పంచుకున్న ప్రేయసి
    Seethala nEtraasruvula agni kaNaallaaga (శీతల నేత్రాశ్రువుల అగ్ని
    raatri nallaga velugu tOndi” (రాత్రి నల్లగా

    See, how casually I slipped in seemingly contradictory
    similes? If people question, it is their lack of imagination that is to be

  10. You may be insulted for ignoring the grand tradition of “blaxpoitation baby”
    (which in Andhra becomes “rakta mallelu” or whatever). Here the trick is to pull
    the reader into your side. Almost feel him ashamed to insult the poetry; in
    fact, tell him this is not poetry — it is “vudaya Sankhaaraavam//cheeDa
    purugula gunDellO simha garjana”. In fact, in your anthology, you should keep a
    poem defending your poetry. I am afraid to write this poetry, let alone read it.
    So, it is left as your homework.
  11. In the end, perhaps, you would like to hear a 12th century poet, in a
    language that he is most familiar with wrote:

    “mEghairamdhuram ambaram (మేఘైర్మధురం అంబరం)
    naktam… tamaala
    drumai” (నక్తం… తమాల ద్రుమై)

    Yes, that was jaya dEva. That all
    folks. Now, let a thousand poems bloom! As an excersize, complete the poems in
    the styles mentioned above.–
    Rama Kanneganti [Jan 20, 2004]
    Yahoo groups

 Posted by at 4:33 pm
Jul 171997

Salutation in Telugu

aIn my previous life, I worked as an informer in linguistics department at Rice University. I was informing them, of course, on Telugu. I learnt a great deal from them about Telugu. I gave them Telugu names as well. Barbara became “vichitra” and a girl with chinese name1 which translates to “True Jade” became “satya mani”(సత్యమణి). They used to shock the Telugus in campus by walking up to them and saying “mee aarogyam elaa undi?” (మీ ఆరోగ్యం ఎలా ఉంది). The question they grappled with is how to address Telugus in the campus.

Of course, people go for years with out calling each other. I have seen women never calling out to their husbands. Some of them have been heard to comment that their husbands won’t listen to them, so why call them at all?

When I was young, if the other person is young enough, I would immediately descend to “arE, orE, Eraa” (అరే, ఒరే, ఏరా). Social graces were not considerably important at that age. Of course, at that age there is an immediate bond with each other, forged over “gOleelaaTa” (గోలీలాట) and “aakaaTa”(ఆకాట).

The trouble comes when one grows up. There was a time, when I started off with “meeru, gaaru” (మీరు, గారు) and descend to “nuvvu” (నువ్వు) as the familiarity increased. But, after a while, it became almost like the courting ritual in the west, where one is afraid to declare love for the fear of being rejected. Assumptions are difficult to make; calling somebody as “nuvvu” is a vulnerability that cannot be traded easily.

KoKu etal showed a way out. For every sentence construct that includes “sambodhana”(సంబోధన), there is an equivalent one that is salutationally neutral (Proof left as an excersize to some aspiring PhD in Telugu. Say, do you think this can be turned into a serious scholastic proposal?). “eppuDu vacchaaroo” (ఎప్పుడు వచ్చారూ) becomes “eppuDoo raavaDam?” (ఎప్పుడు రావడం?). As long as you confine yourself to this subset you can reside in the no man’s land. As the familiarity increases one can jump to the right mode and not sound too awkward. Or, may be spend the rest of the life talking in that neutral tone.

I was told by no less authority than KooraaTi Krishna Madhava Rao, that “guroo” is a favorite among the post graduates in Andhra University. And, also among the rikshawallas. I am not sure if a postgraduate calls a rikshawalla “guroo, jagadaamba center ku teesukupO” (గురూ గారూ, జగదాంబా సెంటరుకు తీసుకుపో). But then, I never lived in Vizag.

The grown up version of “guroo” is “guroo gaaroo”, which is a favored by these post graduates enter the job market. If they are from Kakinada, Vijaywada, they insist on calling you “mastaaroo”. There were times when even I was called “saar” ( How did they know that I went to Saarbrucken?). In some English Medium schools, “saar gaaru” is considered sufficiently respectable.

It is equally difficult to address hubbies. “idigO, mimmalnE” seems to be a choice salutation among the telugu pativratas (who, I was assured, run into millions; please consult the last census where this statistic was taken). Hubbies, I have seen use a gamut of calling conventions, ranging from “EmE” (call by reference) to the actual call by name. I believe Bengalis etc use “radhaa ki maa” (call by value?) convention, which I haven’t seen in andhra dEsam.

I am not sure how the Telugu prativratas here address their pati devatas. I suppose in the best of east meets west tradition, they can use “honey gaaroo”. Or, “evanDee daarling”. Of course some pinco-liberals might call their husbands even by, gasp, actual name.

Of course, what happens behind the closed doors of ones own bedroom is ones own business (unless you happen to be living in the state of Georgia); but there are enough references in literature that assert it can be intimate cooing to “raa, rE”. Consider the following snippet:


“chinnappuDu, ratikELika nunnappuDu vanne sumee raakoTTuTa”.

Ramarao Kanneganti
[17th July, 1997]

PS: The strangest I have heard is my dad being called “Kanneganti Ramarao gaari tanDri garoo”.

(1) Can you tell me what this could be? This girl spoke “Fu Chien”, a taiwanese dialect. Any chinese telugus out there?

 Posted by at 4:37 pm