Author: L.P.D.S.Senevirathne

Computer-aided software engineering (CASE) is the scientific application of a set of tools and methods to a software system which is meant to result in high-quality, defect-free, and maintainable software products.It also refers to methods for the development of information systems together with automated tools that can be used in the software development process.

•Requirements – Surveying tools, analyzing tools

•Designing – Modelling tools

•Development – Code editors, frameworks, libraries, plugins, compilers

•Testing – test automation tools, quality assurance tools

•Implementation – VMs, containers/dockers, servers •Maintenance – bug trackers, analytical tools

CASE classified into 3 categories…

1. Tasks: support only specific tasks in the software process.
2. Workbenches: support only one or a few activities.
3. Environments: support (a large part of) the software process.

Tools
CASE tools support specific tasks in the software development life-cycle. They can be divided into the following categories:

1. Business and Analysis modeling. Graphical modeling tools. E.g., E/R modeling, object modeling, etc.
2. Development. Design and construction phases of the life-cycle. Debugging environments. E.g.,GNU Debugger.
3. Verification and validation. Analyze code and specifications for correctness, performance, etc.
4. Configuration management. Control the check-in and check-out of repository objects and files.
5. Metrics and measurement. Analyze code for complexity, molecularity performance, etc.
6. Project management. Manage project plans, task assignments, scheduling.

Workbenches

Workbenches integrate two or more CASE tools and support specific software-process activities. Hence they achieve:

 a homogeneous and consistent interface (presentation integration).

 seamless integration of tools and tool chains (control and data integration).

An example workbench is Microsoft’s Visual Basic programming environment. It incorporates several development tools: a GUI builder, smart code editor, debugger, etc.

Environments

An environment is a collection of CASE tools or workbenches that attempts to support the complete software process. This contrasts with tools that focus on one specific task or a specific part of the life-cycle. CASE environments are classified by Fuggetta as follows:

• Tool-kits
• Fourth generation
• Language-centered
• Integrated
• Process-centered

In practice, the distinction between workbenches and environments was flexible. Visual Basic for example was a programming workbench.

JavaScript code is executed during the page loading the page loading or when the browser fires an event. All statements are executed at page loading and some statements just define functions that can be called latter.

What is Runtime?

Run time describes software/instructions that are executed while your program is running, especially those instructions that you did not write explicitly, but are necessary for the proper execution of your code.

Declarative programming is a programming paradigm … that expresses the logic of a computation without describing its control flow.

Imperative programming is a programming paradigm that uses statements that change a program’s state.

From my understanding, declarative and imperative are two contrasting programming paradigms.

Declarative programming (also known as functional programming) languages do not attempt to control the flow of a program; they establish desired results i.e. specifying what they want to happen but not how it should happen. HTML is an example of declarative programming because it does not attempt to control the flow of a program; it simply states what it would like to appear but not how it is done.

Imperative programming languages, on the other hand, do attempt to control the flow of a program; they establish commands that will tell the compiler how they wish the code to run but not explicitly what they want to happen.

The virtual machine function is a function for the realization of virtual machine environment. This function enables you to create multiple independent virtual machines on one physical machine by virtualizing resources such as the CPU, memory, network and disk that are installed on a physical machine.

The function is made up of one host OS and multiple guest OSes.

A markup language is used to describe data rather than logic. A typical use of them is to describe document formating, HTML is designed for this for example. But they are sometimes used as general data formats as well, XML is a markup language that is often used to just describe data.

The difference between compiled languages and scripting languages is very fuzzy, both tend to be turing complete in that you can solve any computable problems with them.

There are some general ‘hints’ that you can look for to see if a language is a programming language or not.

• Scripting Languages are often interpreted rather than compiled, or at least provide the option of being interpreted.
  
• Scripting Languages are often built to be fast to work with rather than fast to run.
  
• Scripting Languages tend to come with very extensive standard libraries. Many programming languages do as well, but it is more optional for them.

provides graphical user interface to create the programs.

Actions are defined on events.These events could be occurred by mouse clicking and moving or keyboard strokes.

Focuses on selecting user interface.

Most common languages which follow this paradigm are Visual Basic & C#…

• Objects
• Classes
• Abstraction
• Encapsulation
• Inheritance
• Polymorphism

Objects :-

Objects are the basic run-time entities in an object-oriented programming. They may represents a person, a place, a bank account, a table of data or any item that the program has to handle. They may also represents user-defined data such as vector, time and lists. 

Classes:

Objects contain data, and code to manipulate that data. The entire set of data and code of an object can be made a user-defined data type with the help of class. In fact, objects are variable of the type class. Once a class has been defined, we can create a number of objects belonging to that class. A class is a collection of objects of similar type.

Ex. Vehicle car

Data Abstraction:

Abstractions refer to the act of representing essential features without including background details or explanation. They are commonly known as Abstraction Data Type(ADT).

Encapsulation:

The wrapping up of data and functions into single unit is known as encapsulation. Data encapsulation is a striking feature of a class. The data is not accessible to the outside world, and only those functions which are wrapped in the class can access it. These functions provide the interface between the object’s data and the program.

Inheritance:

Inheritance is the process by which objects of one class acquire the properties of object of another class. The class whose members are inherited is called the Base class and the class that inherits those members is called Derived class. 

Polymorphism:

Polymorphism is another OOP concept. Polymorphism means the ability to take more than one form. An operation may exhibit different behaviors at different instances.

Functional programming is based on the simple premise that your functions should not have side effects; they are considered evil in this paradigm. If a function has side effects we call it a procedure, so functions do not have side effects. We consider that a function has a side effect if it modifies a mutable data structure or variable, uses IO, throws an exception or halts an error; all of these things are considered side effects. The reason why side effects are bad is because, if you had them, a function can be unpredictable depending on the state of the system; when a function has no side effects we can execute it anytime, it will always return the same result, given the same input.

Referential Transparency

A function that returns always the same result for the same input is called a pure function. A pure function, therefore, is a function with no observable side effects, if there are any side effects on a function the evaluation could return different results even if we invoke it with the same arguments.

Lambda calculus is a model of computation devised in the 1930s by Alanzo Church. It’s one process for formalizing a method. Like Turing machines it formalizes the concept of effective computability, thus determining which problems or classes of problems, can be solved. You might be thinking but thats Calculus(Math), how is it related to functional programming or programming in general. It is indeed deeply related.

Lambda expressions in functional programming…

The central concept in the lambda calculus is an expression generated by the following grammar which can denote a function definition, function application.variable, or parenthesized expression. We can think of a lambda-calculus expression as a program which when evaluated by beta-reductions returns a result consisting of another lambda-calculus expression.

A paradigm is a way of doing something (like programming), not a concrete thing (like a language). Now, it’s true that if a programming language L happens to make a particular programming paradigm P easy to express, then we often say “L is a P language.

Some Common Paradigms

We should know this

• Imperative: Programming with an explicit sequence of commands that update state.
• Declarative: Programming by specifying the result you want, not how to get it.
• Structured: Programming with clean, goto-free, nested control structures.
• Procedural: Imperative programming with procedure calls.
• Functional (Applicative): Programming with function calls that avoid any global state.
• Function-Level (Combinator): Programming with no variables at all.
• Object-Oriented: Programming by defining objects that send messages to each other. Objects have their own internal (encapsulated) state and public interfaces. Object orientation can be:
  • Class-based: Objects get state and behavior based on membership in a class.
  • Prototype-based: Objects get behavior from a prototype object.
• Event-Driven: Programming with emitters and listeners of asynchronous actions.
• Flow-Driven: Programming processes communicating with each other over predefined channels.
• Logic (Rule-based): Programming by specifying a set of facts and rules. An engine infers the answers to questions.
• Constraint: Programming by specifying a set of constraints. An engine finds the values that meet the constraints.
• Aspect-Oriented: Programming cross-cutting concerns applied transparently.
• Reflective: Programming by manipulating the program elements themselves.
• Array: Programming with powerful array operators that usually make loops unnecessary.