#coding style

(if (some-predicate foo)

(bar (lambda () (whatever)))

(qux '("whatever" "something"))

)

instead of this more popular way:

(if (some-predicate foo)

(bar (lambda () (whatever)))

(qux '("whatever" "something")))

Specifically: if unbalanced opening parentheses are split off on a separate line, the closing parentheses that balance them should be split off on a separate line too.

Some cases are simple enough that the parse of parentheses pairs is obvious at a glance, but I run into enough situations where that is not the case.

I hear that lispers simply tune out the parentheses and use editors which just automatically manipulate s-expressions so that there is no manual accounting for parentheses at all. I guess you rely on convention about where lines wrap and cues like indentation, and just trust that the parentheses are correct to match what the code shape implies.

Which is fine as a workflow, but it gives me the vibe of an aid that hides certain dimensions of readability. Such aids are fine to use, but should not be allowed to influence judgement of what's best for readability. If you never mentally carefully scan the expression counting open and close parentheses to figure out how it parses, that's fine for coding, but makes you blind to what makes that parentheses matching easier for the human brain, vision, and so on.

Most of my life I have been extremely big on mental habits which ensure correctness. Maybe with experience I would unlock an enlightened approach to lisp where I too stop needing to count or match the parentheses. But for now, I verify parentheses every time I read lisp code I do not have already have cached and verified in my mind.

For every programming language I deal with, I try to carefully parse the code and meticulously mentally step through precisely what it does. For lisp, that includes auditing all the parentheses, and I find the above approach significantly lowers the cognitive load needed to do that.

Incidentally, I am pretty sure this is why most other programming language style conventions settled on putting closing braces on their own dedented line after everything within the braces, and then indenting everything else inside it. To ease mental validation and parsing.

Maybe the lisps, on account of having such a simple syntax, got better automated tooling to ensure syntactical correctness earlier in their history, so the style conventions that developed treated human ease of vetting or parsing parentheses as effectively worthless?

Software engineering phases common interest with other engineering disciplines. In the engineering domain, developing a solution to a given problem, whether building a bridge or making an electronic component, involves a sequence of interconnected steps. These steps or phases occur in software development as well. Also, since the prime objective of software at low cost and in reasonable time, it is essential to perform software development in phases. This phased development of software is often referred to as software development life cycle (SDLC) or software life cycle.

A software development process comprises of different phases. These phases work in top to bottom approach, implying that the phases take inputs from the previous phases, add features, and then produce outputs. The outputs from different phases are referred to as intermediate product, work product, or derivable. The various phases involved in the systematic development of software are shown in pic.

Preliminary Investigation

This phase commences with discussion on the requests made by the user. The requests can be for a new system or modifying the existing system. An estimate is made of whether the identified user needs can be satisfied with the current hardware and software technologies or not. Preliminary investigation verifies the problem and understands the need for required system. It considered whether the proposed system will be cost effective from business point of view and whether it can be developed within existing budgetary constraints. In addition, time factor, which determines the duration of the project, is also considered.

Preliminary investigation should be quick and cost effective. The output of preliminary investigation decides whether the new system should be developed or not. There are three constraints, which decides the go or no-go decision.

Technical: This evaluation determines whether technology needed for proposed system is available or not and if it is available then how can it be integrated within the organisation. Technical evaluation also determines whether the existing system can be upgraded to use new technology and whether the organisation has the expertise to use it or not.

Time: This evaluation determines the time needed to complete a project. Time is an important issue in software development as cost increases with an increase in the time period of a project.

Budgetary: This evaluation looks at the financial aspect of the project. Budgetary evaluation determines whether the investment needed to implement the system will be recovered at later stages or not.

(a) Software Analysis: This phase studies the problem or requirements of software in detail. These requirements define the processes to be managed during the software development. After analysing the requirements of the user, a requirement statement known as software requirement specification (SRS) is developed. After analyses, planning for the project begins. It includes developing plans that describes the activities to be performed during the project, such as software configuration management plans, project and scheduling and the quality assurance plans. In addition, the resources required during the project are also determined.

(b) Software Design: In this phase the requirements are given as ‘defined form’. Design can be defined as a process of deciding information structures, in terms of efficiency, flexibility, and re-usability. During this phase, strategic and tactical decisions are made to meet the required functional and quality requirements of a system. Software design serves as the blueprint for the implementation of requirement in the software system. Each element of the analysis model in the analysis phase provides information that is required to create design models. The requirement specification of software, together with data, functional and behavioural models provide a platform to feed the design task to meet required functional and quality requirements of a system.

(c) Software Coding:  This phase can be defined as a process of translating the software requirements into a programming language using tools that are available. Writing a software code requires a thorough knowledge of programming language and its tools. Therefore, it is important to choose the appropriate programming language according to the user requirements. A program code is efficient if it makes optimal use of resources and contains minimum errors.

Writing an efficient software code requires thorough knowledge of programming. However, to implement programming, coding style is followed. This style is used for writing software code in a programming language.  Coding style also helps in writing the software code efficiently with minimum errors. To ensure that all developers work in a harmonised manner (the source code should reflect a harmonised style, as if a single developer has written the entire code in one session), the developers should be aware of the coding guidelines before the inception of a software project.

(d) Software Testing:  This testing is performed to assure that software is free from errors. Efficient testing improves the quality of software. To achieve this, software testing requires a thorough analysis of the software in a systematic manner. Test plan is created to test software in a planned and systematic manner. In addition, software testing is performed to ensure that software produces the correct outputs. This implies that outputs produced should be according to user requirements.

(e) Software Maintenance: This phase comprises of a set of software engineering activities that occur after software is delivered to the user. The objective of software maintenance is to make software operational according to user requirements. The need of software maintenance is to provide continuity of service. This implies that software maintenance focuses on fixing errors, recovering from failures, such as hardware failures, or incompatibility of hardware with software. In addition, it facilitates future maintenance work by modifying the software code and databases used in the software.

After software is developed and delivered, it may require changes. Sometime, changes are made in software system when user requirements are not completely met. To make  changes in software system, software maintenance process evaluates, controls and implements changes. Note that changes can also be forced on the software system because of changes in government regulations or changes in politics of the organisation.

Case Study: Bridge and Software Development

Requirements analysis, design and implementation are concerned with, what to do, how to do, and the way to do respectively. For example, above listed table shows the phases, involved in building a bridge and also lists the corresponding software development phase.

Building Bridge and Corresponding SDLC Phase

Phase Building Bridge SDLC Phase Formulate the problem by understanding the nature and general requirements of the problem. Understand the load of the bridge it must carry, the approximate locations where it can be built, the height requirements, and so on. Preliminary Investigation. Defining the problem precisely. Specify the site for the bridge, its size, and a general outline of the type of bridge to be built. Software requirement analysis and specifications. Detailing the solution to the problem. Determine exact configuration, size of the cables and beams, and developing blueprints for the bridge. Software design. Implementing. Correspond to actual building of the bridge. Software coding. Checking. Specify load, pressure, endurance and robustness of the bridge. Software testing. Maintaining. Specify repainting, repaving, and making any other repairs, which are necessary. Software maintenance.

Today ended my wife’s summer break, and so begins my next several weeks of very intense preparation before I begin App Academy.

I started off by working quickly through the App Academy curriculum on github. I always learn best by being exposed to material several times, over time, so I figured it would be best to start looking ahead as much as possible. Since there is several weeks of material, I don’t plan to do all the exercises, and I plan to work fast (part of being able to work in an intense and fast-paced environment is practice, so I figured I should begin practicing just that). I figure it’s best to place myself into a timed, fast-paced context on my own, because a huge part of learning is learning to learn.

Today involved going over the basics once more, including coding style and debugging. I was very surprised to learn that Byebug can be used as a conditional debugger—super helpful if a method is called several times in your program, and you need to see which call is causing a problem.