skip to content
08 September 2014

Ten Software Keywords That Make You Look Smarter

look-smarter

They say the coat doesn’t make the man, I say the right quote can make a developer punch above the waistline.

In this post, I selected a group of my favourite keywords which make me smile and think “nerd” every time I hear them.

1 – The God Function

This is the all-in-one function (method). It is one function that does everything, is it like 100 lines or more. Obviously, writing a God Function contradicts with clean and readable code principles and usually the people guilty of using it are beginners and pros coming from other domains (like mathematicians).

This term is usually used in a sarcastic way to mock a function that is long and needs refactoring.

2 – Vertical Concerns

It is a concern not directly related to the piece of code that you write. So, when you are writing some code to save a user info in the database, logging the event and notifying other systems that a record has been added are mostly vertical concerns.

Vertical concerns are usually dealt with in C# with attributes, Membership Provider attributes are a good example.

3 – Cross-Cutting Concerns

Quoting from Wikipedia:

Cross-cutting concerns are aspects of a program that affect other concerns. These concerns often cannot be cleanly decomposed from the rest of the system in both the design and implementation, and can result in either scattering (code duplication), tangling (significant dependencies between systems), or both.

For instance, if writing an application for handling medical records, the indexing of such records is a core concern, while logging a history of changes to the record database or user database, or an authentication system, would be cross-cutting concerns since they touch more parts of the program.

http://en.wikipedia.org/wiki/Cross-cutting_concern

4 – HATEOAS

Quoting from Wikipedia:

HATEOAS, an abbreviation for Hypermedia as the Engine of Application State, is a constraint of the REST application architecture that distinguishes it from most other network application architectures. The principle is that a client interacts with a network application entirely through hypermedia provided dynamically by application servers. A REST client needs no prior knowledge about how to interact with any particular application or server beyond a generic understanding of hypermedia. By contrast, in a service-oriented architecture (SOA), clients and servers interact through a fixed interface shared through documentation or an interface description language (IDL).

The HATEOAS constraint decouples client and server in a way that allows the server functionality to evolve independently.

http://en.wikipedia.org/wiki/HATEOAS

I first heard this term long time ago (2009?) from Jim Webber when I was attending an event on REST.

5 – Ubiquitous Language

Quoting from Martin Fowler:

Ubiquitous Language is the term Eric Evans uses in Domain Driven Design for the practice of building up a common, rigorous language between developers and users. This language should be based on the Domain Model used in the software – hence the need for it to be rigorous, since software doesn’t cope well with ambiguity.

http://martinfowler.com/bliki/UbiquitousLanguage.html

6 – Fluent Interface

Quoting from Wikipedia:

A fluent interface (as first coined by Eric Evans and Martin Fowler) is an implementation of an object oriented API that aims to provide for more readable code.

A fluent interface is normally implemented by using method cascading (concretely method chaining) to relay the instruction context of a subsequent call (but a fluent interface entails more than just method chaining). Generally, the context is defined through the return value of a called method self-referential, where the new context is equivalent to the last context terminated through the return of a void context.

http://en.wikipedia.org/wiki/Fluent_interface

A theoretical example of a fluent interface usage would be something like:
member.Name("Adam").Country("England").City("London");

7 – Optimistic Concurrency Control

Quoting from Wikipedia:

Optimistic concurrency control (OCC) is a concurrency control method applied to transactional systems such as relational database management systems and software transactional memory. OCC assumes that multiple transactions can frequently complete without interfering with each other. While running, transactions use data resources without acquiring locks on those resources. Before committing, each transaction verifies that no other transaction has modified the data it has read. If the check reveals conflicting modifications, the committing transaction rolls back and can be restarted. Optimistic concurrency control was first proposed by H.T. Kung.

OCC is generally used in environments with low data contention. When conflicts are rare, transactions can complete without the expense of managing locks and without having transactions wait for other transactions’ locks to clear, leading to higher throughput than other concurrency control methods. However, if contention for data resources is frequent, the cost of repeatedly restarting transactions hurts performance significantly; it is commonly thought that other concurrency control methods have better performance under these conditions. However, locking-based (“pessimistic”) methods also can deliver poor performance because locking can drastically limit effective concurrency even when deadlocks are avoided.

http://en.wikipedia.org/wiki/Optimistic_concurrency_control

8 – Cyclomatic Complexity

Quoting from Wikipedia:

Cyclomatic complexity is a software metric (measurement). It was developed by Thomas J. McCabe, Sr. in 1976 and is used to indicate the complexity of a program. It is a quantitative measure of the complexity of programming instructions. It directly measures the number of linearly independent paths through a program’s source code.

Cyclomatic complexity is computed using the control flow graph of the program: the nodes of the graph correspond to indivisible groups of commands of a program, and a directed edge connects two nodes if the second command might be executed immediately after the first command. Cyclomatic complexity may also be applied to individual functions, modules, methods or classes within a program.

One testing strategy, called basis path testing by McCabe who first proposed it, is to test each linearly independent path through the program; in this case, the number of test cases will equal the cyclomatic complexity of the program.

http://en.wikipedia.org/wiki/Cyclomatic_complexity

I was first introduced to this term by ReSharper when a legacy code showed as high cyclomatic complexity.

9 – Responsive Web Design

Quoting from Wikipedia:

Responsive web design (RWD) is a web design approach aimed at crafting sites to provide an optimal viewing experience—easy reading and navigation with a minimum of resizing, panning, and scrolling—across a wide range of devices (from mobile phones to desktop computer monitors).

http://en.wikipedia.org/wiki/Responsive_web_design

10 – Duck Typing

Quoting from Wikipedia:

With object-oriented programming languages, duck typing is a style of typing in which an object’s methods and properties determine the valid semantics, rather than its inheritance from a particular class or implementation of an explicit interface. The name of the concept refers to the duck test, attributed to James Whitcomb Riley (see history below), which may be phrased as follows:

When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.

In duck typing, a programmer is only concerned with ensuring that objects behave as demanded of them in a given context, rather than ensuring that they are of a specific type. For example, in a non-duck-typed language, one would create a function that requires that the object passed into it be of type Duck, in order to ensure that that function can then use the object’s walk and quack methods. In a duck-typed language, the function would take an object of any type and simply call its walk and quack methods, producing a run-time error if they are not defined. Instead of specifying types formally, duck typing practices rely on documentation, clear code, and testing to ensure correct use.

http://en.wikipedia.org/wiki/Duck_typing

Conclusion

Joke aside, if I am interviewing someone and he/she is using some key phrases, where relevant, this would be a great plus which proves they know what they are talking about.

We advise using these keywords in an interview with caution…

2Comments
leave your own
  • DalSoft September 18th, 2014

    I remember you asking me if I’ve heard of HATEOAS in my interview!

  • Adam Tibi September 19th, 2014

    Do you know the answer now? 🙂 I remember that you didn’t know it back then, but you got the job anyway 🙂

Leave a Reply

Gravatar