As I continue my learning journey into programming, methodologies and processes, I've decided to organize some of the interesting related events on a timeline.
This provides an interesting perspective on the sequence of events that lead to where we are now as an industry.
Ruslan Spivak
https://www.linkedin.com/in/ruslan-spivak/
Contributions are welcome (issues, PRs).
An imaginary computer invented in 1936 by English mathematician Alan Turing.
A paper is published, called "On Computable Numbers, with an Application to the Entscheidungsproblem (Decision Problem)".
The term "Turing Machine" is not mentioned in the paper, Alan uses the term "Computing Machine".
The term Turing Machine was first used in 1937, and remained the standard since then.
This is the first time the concept of a stored program computers was introduced, where the instructions and the data were on the same store.
References:
- http://www.scholarpedia.org/article/Turing_machine
- https://en.wikipedia.org/wiki/Turing_machine
- https://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf
Alan turing created the initial design of the Bombe electro mechanical device which was used to decipher the german Enigma machine.
The British bombe was developed from a device known as the "bomba" (Polish: bomba kryptologiczna), which had been designed in Poland at the Biuro Szyfrow (Cipher Bureau) by cryptologist Marian Rejewski, who had been breaking German Enigma messages for the previous seven years, using it and earlier machines.
References:
An electromechanical computer designed by Konrad Zuse who was a civil engineer, inventor and businessman.
Z3 is considered to be the worlds first working, programmable, Turing Complete in theory, digital computer and was used to make aerodynamic calculations.
The original computer was destroyed in 1943 by the allied bombings of Berlin. A replica of the machine was built in the 60s and it is on display in the Deutsches Museum
References:
- https://en.wikipedia.org/wiki/Z3_(computer)
- https://www.computerhistory.org/timeline/1941/
- https://cs.nyu.edu/courses/summer17/CSCI-UA.0004-002/bootstrap_computer_history_new/zuse.html
The machine was initially conceived in 1937 and built by 1942 by John Vincent Atanasoff and Clifford Berry.
Atanasoff was a mathematics and physics professor at the Iowa state college, and Berry a graduate student.
The computer was not programmable and was not implementing stored program architecture (Von Neumann Architecture).
ABC was in the midst of the patent dispute, in which it was ruled that the ENIAC derived many basic ideas from ABC.
Rerecences:
- https://www.britannica.com/technology/Atanasoff-Berry-Computer
- https://ethw.org/Milestones:Atanasoff-Berry_Computer,_1939
Isaak Asimov, American writer and professor of biochemistry at Boston University.
The laws are to be followed by robots in his stories.
The three laws are:
- The First Law: A robot may not injure a human being or, through inaction, allow a human being to come to harm
- The Second Law: A robot must obey the orders given it by human beings except where such orders would conflict with the First Law
- The Third Law: A robot must protect its own existence as long as such protection does not conflict with the First or Second Law
References:
- https://en.wikipedia.org/wiki/Three_Laws_of_Robotics
- https://www.britannica.com/topic/Three-Laws-of-Robotics
A set of computers developed by the British in the years 1943-1945 to help decrypt the Lorenz cipher.
The computers were used to break the codes of the German Lorenz SZ-40 cipher machine which was used by the German High Command.
Designed by Tommy Flowers, an electronics engineer of the Post Office Research Station (part of the General Post Office, GPO).
The prototype, Colossus Mark 1 was shown to be working on December 1943.
An improved Colossus Mark 2 was first working on June 1944.
Winston Churchill issued an order for the destruction of the machines after the war.
The existence of the machines was kept secret until 1970.
Colossus was not used to decipher the Enigma, it was "Bombe", an electro mechanical device created by Alan Turing, in 1939.
References:
- https://en.wikipedia.org/wiki/Colossus_computer
- https://www.britannica.com/technology/Colossus-computer
- https://www.tnmoc.org/colossus
The first programmable, electronic, general purpose digital computer, the building of which was completed on 1945.
A US government funded project, initially designed to calculate artillery firing tables.
The project began on 1943, John von Neumann joined the project on 1944.
Its first job was to perform calculations to help with building hydrogen bombs.
Some numbers:
- Weight: 30 tons approx.
- Height: 2 Meters
- Depth: 1 meter
- Length: 30 meters (U shaped)
References:
- https://en.wikipedia.org/wiki/ENIAC
- https://www.hp.com/ca-en/shop/offer.aspx?p=computer-history-all-about-the-eniac
- https://www.britannica.com/technology/ENIAC
John von Neumann, mathematician and physicist proposed the architecture in 1945.
The architecture meant that the computer is easier to reprogram, as the instructions and the data are stored in memory.
This relates to the development of the stored program concept, which started with the Turing Machine in 1936.
Most personal computers, laptops, smartphones and a wide range of embedded systems use the Von Neumann Architecture.
References:
In 1950, Alan Turing publishes a paper called "Computing Machinery and Intelligence" in which he speculates about the possibility to create machines that can think and proposes the "Turing Test".
Turing Test is a test of a machines ability show intelligent behavior similar to or indistinguishable from that of a human.
The test proposes a natural language conversation between human and a machine which is observed by a human evaluator.
The evaluator can only observe the written conversation and is aware that one of the sides is a human and the other is a machine.
If the evaluator could not reliably tell the machine from the human, then it is said that the machine has passed the test.
Many argue that the test is far from perfect.
The field of artificial intelligence is founded as an academic discipline.
The term officially introduced by John McCarthy during a workshop which marked the beginning of the discipline.
References:
- https://en.wikipedia.org/wiki/History_of_artificial_intelligence
- John McCarthy (1927-2011): Artificial Intelligence Interview
John McCarthy began developing Lisp while he was in the MIT.
Lisp is an acronym for List Processing, as linked lists are one of the Lisp's major data structures.
The language was used in IBM 700/7000 series mainframe computers.
Lisp pioneered many ideas in computer science, including:
- Tree data structures
- Dynamic typing
- Conditionals
- Recursion
https://en.wikipedia.org/wiki/Functional_programming
Invented by John McCarthy to simplify manual memory management in Lisp.
Garbage collection relieves the programmer from doing manual memory management.
References:
Project Mercury was the first human spaceflight program of the United States, running from 1958 through 1963.
Developers working on the code for the Mercury space program used a form of Test Driven Development.
The project was run in very short iterations (half day).
The team applied an Extreme Programming practice where tests were written before each micro increment.
References:
- https://en.wikipedia.org/wiki/Project_Mercury/
- https://arialdomartini.wordpress.com/2012/07/20/you-wont-believe-how-old-tdd-is/
- https://flowoftesting.wordpress.com/2013/12/21/project-mercury-and-death-of-testing/
- https://www.craiglarman.com/wiki/downloads/misc/history-of-iterative-larman-and-basili-ieee-computer.pdf
- https://raidoninc.com/blog/what-is-test-driven-development
COBOL is an acronym for "common business oriented language", an English like computer programming language designed for business use.
Still widely used in applications deployed on mainframe, however most of the use is for maintenance as programs are migrated to new platforms.
Designed by CODASYL (Conference on Data System Languages), a volunteer organization to promote effective data system analysis design and implementation.
The language was designed by a committee, and partly based on Flow-Matic, a business oriented programming language created by Grace Hopper.
The idea was to create a computer language for business with emphasis on input and output with numbers and strings as data types.
COBOL 2002 included support for object oriented features.
In 2019 IBM Systems magazine article it was stated that there is a shrinking availability of developers available for COBOL.
The industry has tried the below to mitigate COBOL skills shortage:
- Rewrite existing COBOL mainframe application to more modern languages like Java and move it to the cloud
- Do more withe less, change the way existing programs are maintained
- Outsource COBOL development and maintenance, a step which has been proven to be less effective
References:
- https://en.wikipedia.org/wiki/COBOL
- https://blog.microfocus.com/amazing-grace-hopper-birthday/
- https://fedtechmagazine.com/article/2017/09/how-cobol-became-early-backbone-federal-computing
- https://archives.lib.umn.edu/repositories/3/resources/35
- https://techchannel.com/Enterprise/10/2019/closing-cobol-programming-skills-gap
Developed by Kristen Nygaard and Ole-Johan Dahl in the Norwegian Computing Center in Oslo as part of writing computer simulation programs.
Simula introduced:
- Objects
- Classes
- Inheritance
- Subclasses
Simula has influenced the creators of C++ (Bjarne Stroustrup) and Java (James Goosling)
Formation of the first computer science department at Purdle University in West Lafayette, Indiana, United States.
Douglas Engelbart was working in in Stanford Research Institute (SRI) on improving human-computer interaction.
The goal was to find easy and efficient way to use computer interfaces.
In 1963 he created a note in his notebook about a "bug" with 2 wheels with which it would be easier and more natural to use to input X and Y coordinate data.
References:
- https://www.geeksforgeeks.org/who-invented-first-computer-mouse/
- https://en.wikipedia.org/wiki/Computer_mouse
The word daemon was first used by a team at MIT working on Project MAC (the Project on Mathematics and Computation).
During the project a research was conducted into operating systems, artificial intelligence and theory of computation.
John McCarthy (inventor of Lisp) was one of the team members.
The use of the word was inspired by the Maxwell's daemon, which is a thought experiment to violate the second law of thermodynamics (entropy, direction of a natural process).
Maxwell's daemon was an imaginary agent which helped sort molecules of different speeds and worked tirelessly in the background.
References:
- https://en.wikipedia.org/wiki/Daemon_(computing)
- https://ei.cs.vt.edu/~history/Daemon.html
- https://en.wikipedia.org/wiki/Maxwell%27s_demon
John von Neumann was a Hungarian-American mathematician, physicist, computer scientist, engineer and polymath (an individual who's knowledge spans a substantial number of subjects).
The paper is a thought experiment into the possibility of creating self replicating pieces of code and describes how a computer program could be designed to replicate itself.
Von Neumann's design is considered to be the first computer virus, and Von Neumann considered to be the theoretical father of computer virology.
TBD
References:
Winston Walker Royce was a director at the Lockheed (currently Lockheed Martin) aerospace company.
Royce started developing new methodologies for improving the management of software projects.
Winston Royce released a paper called "Managing the development of large software systems".
Royce's paper is considered to be the paper which defines the waterfall model of software process.
However in the paper Royce states that the waterfall process is doomed to fail.
The first time when there is experience with the software is in the testing phase. At this phase it is impossible to make major changes to the software without serious setback in resources and schedule. There is a need to modify the process in order to minimize the risk.
Winston Royce presents five additional features that must be added to the basic approach to eliminate most of the development risks:
- Program Design
- Document the Design
- Do it twice
- Plan, control and monitor testing
- Involve the customer
The additional steps are going to cost money, but the costs to recover far exceed the additional costs of the steps.
References:
The Creeper program is often regarded as the first computer virus.
It was designed by Bob Thomas at BBN as a security test to see if a self replicating program was possible.
BBN (originally Bolt, Beranek and Newman Inc) started at MIT and is known for DARPA sponsored research and development company.
Key player in inventing the internet, BBN registered the domain bbn.com on 24 April 1985, making it the second oldest domain name on the internet.
John McCarthy was a consultant at BBN. On 209 the company was fully acquired by Raytheon.
Email was invented at BBN on 1971, including the use of @ sign in an email address.
Developed at Bell Labs by Dennis Ritchie.
Successor of the programming language B.
B was developed at Bell Labs around 1969 by Ken Thompson and Dennis Ritchie.
Since 2000, C has constantly ranked among the top two languages in the TIOBE index.
The TIOBE (The Importance Of Being Earnest) Programming Community index is an indicator of the popularity of programming languages.
The Importance Of Being Earnest is also the name of a play written by Oscar Wilde at the end of the nineteenth century.
By choosing this name, the founders of TIOBE emphasize their sincere and professional attitude towards customers, suppliers and colleagues.
References:
An article published in IBM Systems Journal by Larry Constantine and others, talks about the concepts of Coupling and Cohesion.
The principles are crucial in order to design optimum module structure and interfaces.
- Cohesion: grouping of functionally related processes into a particular module
- Coupling: flow of information or parameters passed between modules, optimal coupling reduces the interfaces of modules and the resulting complexity of the software
Two modules considered coupled, when a change in module A causes a need for a change in module B.
Coupling is considered bad for software, while cohesion considered good for software.
References:
Created by Trygve Reenskaug while working on Smalltalk 79 at the Xerox Palo Alto Research Center.
MVC was created "as a general solution to the problem of users controlling a large and complex data set".
The approach models items of interest to the user as a logical Model and then provides a View and ways to manipulate the data, ie the Controller.
The metaphor introduces the below terms:
- Thing: An abstraction of something of interest to the user, which exists in the real world
- Model: An active representation of the abstraction (thing) in the form of data in a computer system
- View: Views are attached to a model, and are capable of representing the model on a screen in different ways as required by the users
- Controller: A link between the user and the system, a way to manipulate and to configure the view (View Options)
- Editor: A special type of controller, which permits users to modify the information presented by the view
The MVC pattern has evolved giving rise to various variants like:
- HMVC: Hierarchical Model View Controller
- MVA: Model View Adapter
- MVP: Model View Presenter
- MVVM: Model View Viewmodel
References:
- https://www.duo.uio.no/bitstream/handle/10852/9621/Reenskaug-MVC.pdf
- https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller
- https://www.martinfowler.com/eaaDev/uiArchs.html
Department of Defense Standard 2167A, a document which establishes "uniform requirements for software development which are applicable through the system lifecycle" which captures the waterfall approach for software development.
The development cycle includes the below six phases:
- Requirements Analysis
- Preliminary Design
- Detailed Design
- Coding and Unit Testing
- Integration
- Testing
References:
- https://en.wikipedia.org/wiki/DOD-STD-2167A
- https://www.product-lifecycle-management.com/download/DOD-STD-2167A.pdf
The first internet domain that was ever registered was symbolics.com.
It belonged to Symbolics Inc., a computer manufacturer that designed and built single user machines designed to run the the programming language lisp.
Symbolics was a spin off from the MIT AI Lab.
References:
First use of the term "Scrum" in a paper called "The New New Product Development Game" by Hirotaka Takeuchi and Ikujiro Nonaka.
The authors provide an approach to product development for increased speed and flexibility.
The approach is build upon case studies from manufacturing firms in the automotive, photocopier and printer industries.
References:
- http://damiantgordon.com/Methodologies/Papers/The%20New%20Product%20Development%20Game.pdf
- https://en.wikipedia.org/wiki/Scrum_(software_development)
System development process is complicated and complex, therefore maximum flexibility is required.
An approach is needed that enables development teams to operate adaptively within a complex environment using imprecise processes.
Scrum methodology is a metaphor for the game of Rugby, where the primary goal is to move the ball forward by the team.
Scrum is an empirical approach to software development which emphasizes flexibility and responsiveness.
Ken Schwaber and Jeff Sutherland developed the similar approaches in parallel and later worked together to integrate their ideas into a single framework.
Ken Schwaber: Software developer, product manager and industry consultant, runs https://www.scrum.org/.
Jeff Sutherland: Masters in Statistics, Professor in Mathematics.
Scrum in essence:
- Increments of work are delivered in short cycles known as sprints, used to evolve the product
- Scrum team has a Scrum Master, A product owner and developers who are accountable to turn a selection of work into value
- The Scrum Team and the stakeholders inspect the results of the Sprint and adjust for the next one
Evolution favours those that operate with maximum exposure to the environment change and have optimized for flexible adaptation to change.
Scrum projects have the below characteristics:
- Flexible deliverable: the content of the deliverable it dictated by the environment
- Flexible schedule: the deliverable may be required sooner or later than initially planned
- Small teams 3-6 members, there may be multiple teams
- Frequent reviews, a functional executable must be prepared by each team for each review
- Collaboration, intra and inter
References:
- https://en.wikipedia.org/wiki/Scrum_(software_development)
- https://www.amazon.com/Business-Object-Design-Implementation-Proceedings/dp/3540760962
- http://www.jeffsutherland.org/oopsla/schwapub.pdf
- https://en.wikipedia.org/wiki/Ken_Schwaber
- https://en.wikipedia.org/wiki/Jeff_Sutherland
Kent Beck developed Extreme Programming software development methodology while working at Chrysler Corporation payroll system together with Ward Cunningham and Ron Jeffries.
C3: Chrysler Comprehensive Compensation System.
Extreme programming is a methodology intended to improve software quality and responsiveness to changing customer requirements.
The methodology takes its name from the idea that the beneficial elements of software development are taken to "extreme" levels.
Scrum can be applied to any project that benefits from an iterative approach while XP is about programming.
Extreme programming takes the best practices to extreme levels.
Values:
- Communication: Face to face discussions with the help of a whiteboard
- Simplicity: What is the simplest thing that will work? avoid waste, keep the design of the system simple
- Feedback: Constant feedback about team practices and design
- Courage: Effective action in the face of fear, stop doing something that does not work, accept feedback, raise issues
- Respect: Members of the team need to respect each other, provide and accept feedback and work together
Practices:
Outer Circle:
- Whole Team: All contributors of the project sit together, everyone on XP team contributes in any way that they can
- Planning Game: Release planning, and iteration planning
- Small Releases: Every iteration the team delivers running tested software delivering business value
- Customer Tests: Customer defines one or more automated tests, team builds the tests and uses them to prove to themselves and the customer that the feature is implemented correctly
Middle Circle:
- Continuous Integration: Daily builds are for wimps, XP teams build multiple times per day, to mitigate integration hell (CI, Grady Booch 1991, UML)
- Collective Code Ownership: Code is owned by the whole team and not a programmer who wrote it, due to pair programming
- Coding Standards: Team follows a single standard defined by the team so that the code looks as if it was written by one person
- Metaphor: Use common system of names to be sure that everyone understands how the software works and where to look for a functionality
- Sustainable Pace: XP teams work in a pace that can be sustained indefinitely
Inner Circle:
- Simple Design: The design is simple but adequate and exactly suited for the current functionality of the system, design is "all the time thing", revised throughout the project
- Pair Programming: All production code is built by two programmers sitting side by side at the same machine, as pairs switch, everyone gets the benefits of everyone's specialized knowledge
- Test Driven Development: Short cycles of adding tests then making them work, this way teams produce code with nearly 100% coverage
- Refactoring: Refactoring is contiguous design improvement (Martin Fowler), increasing cohesion while lowering coupling
Other Practices include User Stories and Story Points.
References:
Invented by Kent Beck in 1997, user stories are an informal general explanation of a software feature written from a perspective of the end user. The purpose of a user story is to describe the value which is provided by the end user by implementing the described feature.
Templates for User Stories:
- "As a
roleI cancapability, so thatreceive benefit" - "As
whowhenwhere, I wantwhatbecausewhy" - "As a
type of user, I wantsome goalso thatsome reason"
User stories are not software system requirements. They are non technical language descriptions of what the users are trying to achieve.
References:
- https://en.wikipedia.org/wiki/User_story
- https://www.atlassian.com/agile/project-management/user-stories
- https://www.mountaingoatsoftware.com/agile/user-stories
Invented by Ron Jeffries as part of XP. Story points are originally an XP idea, also adopted by Scrum methodology.
Originally, stories were estimated in time units. The term "ideal day" was used, where the developers are not bothered by external interferences. An estimation was suggested where tree real days are required to get the work done of an "ideal day". The stakeholders were confused as to how a days work would take three days to get done.
To prevent comparison with time, the team started to say "Points" instead of "Ideal Days".
An attempt to normalize and compare teams based on story points is not advised.
References:
- https://www.parabol.co/blog/story-points/
- https://ronjeffries.com/articles/019-01ff/story-points/Index.html
- The Genesis of Story Points
CAPTCHA is patented by Eran Reshef, Gili Raanan and Eilon Solan.
An acronym for Completely Automated Public Turing test to tell Computers and Humans Apart.
Captcha is called a reverse Turing test, because the test is administered by a computer and not by a human, as in the standard Turing test.
Snowbird, Utah
The word Agile was proposed by Mike (Miguel) Beedle, and accepted as the team, the word game from the book “Agile Competitors and Virtual Organizations”.
Other words that were proposed: Adaptive, Essential, lean, lightweight.
Mike Beedle is a theoretical physicist, and his masters was about chaotic and nonlinear systems.
This is where the idea of “teams at the edge of chaos” came from, a team that works as an adaptive system.
The principles were written on the second day, by 8 people, seen on the background picture of the Agile Manifesto website, the rest of the group approved it.
References:
The term is coined by Eric Evans in his book published on August of 2003.
DDD is a software design approach, which focuses on modeling the software to match a domain based on input provided by domain experts.
The goals of the approach are to:
-
Place the primary focus onto the core domain and domain logic
-
Base complex design on a model of the domain
-
Creative and iterative collaboration between technical and domain experts
-
References:
Gradle Build Tool 0.1 released by original Gradle OSS project founder Hans Dockter
The term "DevOps" was coined by Patric Debois, who organized the first DevOps conference in Belgium.
References: