Computers don't do anything without software. Some software is burned or
flashed into ROM or other chips to become 'firmware', but it all started life
Types of Software: Operating Systems; Utilities;
Malware: Virus, Worms, Spyware/Keystroke Loggers, Rootkits, Trojans, Bots;
Security: Anti-Virus, Firewall, IDS, Anti-Spam, Surveillance & Motion Detection; Programming Languages, IDE, Frameworks;
Version Control; DBMS; Artificial Intelligence;
Web Servers: HTTP, SMTP, POP, IMAP, SSL;
Application Software: Office/Productivity, Single vs. Multi-user vs. Enterprise!, ERP, 'Vertical Market' for practically every category of business;
Games; Graphics: CAD 2D & 3D, Drawing, Animation, Photo Editors, Video Capture, Editing & Compositing; SCADA & other Process Control; &c, &c...
Was this a comprehensive list? What's left out? Sometimes 'free software' and 'proprietary software' are the answer for
'what kinds of software are there?' but that's not what the instructor's looking for on a quiz...
Software (Outlines software chapter in text). 'Structured' and 'Object Oriented' are the two most
Diagram on board how software can get to the OS Executive: 1GL, 2GL, 3GL to Executable,
4GL is DB-aware and 'writes' 3GL code as developer drags/drops, middleware like .NET Framework or JVM-Java Virtual Machine
runs Bytecode, which is a compilation from a 3GL like VB or C# or Java. Open Source scripts like PHP, Perl, Ruby, or Python are Interpreted
line at a time by their interpreter which produces binary for the Executive.
DMA and SMP are included in the discussion.
Version Control Software is Essential for Software Development
Professional software development, revisions, and upgrades are managed using 'version control' or 'revision control' systems so that programmers don't step on each others' efforts as they work, and managers can control and audit software as it is
installed and revised on the computers they manage. 'Configuration Managers' use
version control systems to tie the software they install all the way back to the requirements definitions and other contractual agreements with the developers to make sure the
software they install is what was ordered.
GitHub is the #1 most used version control software, either at github.com or with git installed
on private servers. Setting up and working projects with buddies is a good way to develop skills
you can show off in a technical interview. Along with a LinkedIn profile and portfolio, a GitHub account
can be the most powerful piece in a professional portfolio!
There are dozens of other source code development and revision control applications in the legacy.
Microsoft provides 'VSS-Visual Source Safe' for small projects,
and 'TFVC-Team Foundation Version Control' can scale to large projects. There are Open Source tools for revision control. 'CVS-Concurrent Versions System' has decades of use and is freely available. On-line resources like Git Hub are popular with open-source development teams, as are SourceForge, BitBucket, and several other websites that facilitate collaboration on software projects.
Adopting a version control software is one step an organization can take to maturity in application development.
There is a very real risk that changes to a business system can 'take the system down'
or take the business down. Procedures are important to test, accept, install, roll back the
installation if necessary, and recover data lost in the process.
'Configuration Manager' is one of the higher-paid specialties in IT, git started on these valuable skills today!
Generations of Programming Languages:
This is not to be confused with 'Generations of Computers', which is mostly about advances in miniaturization
of hardware components. The generations of programming languages do advance across the same decades as generations of computers,
but they're all in current use today, none of the generations is obsolete. It's important for IT pros to
understand how each generation of code is produced, all impact system security, recoverability, and portability among platforms.
1GL is Binary Code or Machine Code for the instruction set of a particular CPU or 'family' of CPUs.
Binary code is not 'portable' from one CPU family to another -- Binary for RISC is very different from
and won't run on a CISC.
Binary code is seldom written
directly, is usually the result of assembling assembly code, compiling or interpreting 3GL or 4GL code,
or a 'virtual machine' like JVM-Java, .NET Framework, or IBM's VM or SLIC that reads compiled 'byte code' and outputs binary code
to the system executive.
1G code consists of 'zeroes and ones' arranged in bytes and words.
In a Windows environment files with 1GL have a .exe as the file extension, called 'executables'.
The Little Man Computer is a mind-game
that may provide the best introduction to how machine code works. A simple sequence of 3GL statements like
A=1; B=2; C=A+B; PRINT C takes a dozen on more instructions in a 1GL.
- 2GL is Assembly Language, which has a one-to-one
correspondence with the Machine Code for a CPU, but uses human readable mnemonics,
aka abbreviations, for the binary instructions. Assembler Language is run thru an 'assembler' that
produces the binary machine code, aka binary executable or executable, that is put to the OS executive to run.
- 3rd Generation Languages
are our more modern programming languages, from ancient ALGOL and FORTRAN,
and COBOL thru BASIC, C, C++, C#, VisualBasic.net, Java, and a host of other 3GLs.
When you compile a 3GL script, you get a binary, executable, file that can be put to the
executive of a CPU 'family' and run. Most 3GLs are 'structured' with statements to handle logical structures
of sequence, alternative selections, loops, and error handling. Most popular 3GLs are also 'object oriented'
and support OO concepts of properties, methods, events, inheritance, and other higher-level OO features.
- 4th Generation Languages
make many common programming tasks automatic,
especially user interface, forms, and database transactions.
For example, a complex form might take a 3GL programmer days to write but with a 4GL the effort might be reduced to hours.
Today's 4GLs 'make the computer the programmer'
and write 3GL scripts as the programmer uses the GUI to drag & drop components of the interface onto forms or web pages.
A powerful 4GL can do most of the routine coding for user interfaces, web-services, and database.
4GLs allow developers to focus on business rules and user experience while the 4GL handles the complexities of the UI.
4GLs are usually associated with a family of programming languages. VisualStudio works with the .NET framework
and many other languages including its Visual Basic and C# and most databases including their own SQLServer.
Zend works with PHP and MySQL, Oracle, and IBM's IMS and DB2 databases.
Java NetBeans and Enterprise NetBeans run on any machine known to man and connect to Java, Oracle, and other databases.
IBM's i5 is a powerful, proprietary, 4GL machine that inherits all the function of their AS400 and integrates with
practically any environment or database, most often IBM's proprietary DB2.
Sketch and discuss the several ways program code gets to
the OS Executive from the programmer and some of the tradeoffs
1GL: Is 'Binary Code' for a CPU It is rarely coded directly,
except for PAL and other 'microcoded' drivers and patches for our hardware.
Binary code is usually the result of assembling a 2GL script or compiling a 3GL script.
If the 3GL source code for an application's executables is available, it may be
re-compiled in a new environment where the 3GL will run. Otherwise,
having only the binary executables available locks the application into
the platform where the binaries were produced.
A very common exception to assembly or compilation producing files with binary machine code
is 'interpreted' languages like Python or PHP that read source code directly and convert it to
machine code 'on the fly'.
When applications are purchased, like Word, PhotoShop, or software for Vertical Markets, it's likely their
software components are compiled, binary, machine code.
It is very difficult to 'reverse compile' machine code to reveal the original design of an application.
Distributing applications as binaries preserves trade secrets, and
the owners don't want to give away the intellectual design properties.
- 2GL: is human-readable 'Assembler Language' appropriate for a CPU like Intel x86 or RISC 68K.
There is a nearly one-to-one correspondence between between Binary Code and the Assembly Code for a solution.
Applications that have components that are coded with 2GL are 'locked into' their platforms,
may be very expensive to convert so they assemble and run efficiently elsewhere.
3GL: is even more easily human-readable scripting languages like
C, C+, C++, BASIC, Visual Basic, COBOL, C#, PHP and many other modern programming languages.
Traditional source code is run thru a Compiler appropriate for the local CPU
which outputs Binary coded 'executable', '.exe' files
that can be presented to the OS Executive.
Developers may distribute only the
binary (.exe) or byte-code (.dll) and keep their source code a secret. This effectively locks
the application and data to a platform.
'Reverse compilation' may work in some attempts
to reuse the binary code in another environment, but it produces 3GL code that is
difficult to work with.
- 4GL today is usually a powerful GUI that automates the programming of most elements of the
interfaces with user and database. For example, Microsoft's powerful Visual Studio 4GL
produces the 3GL C# or Visual Basic scripts that present the GUI to the application's users.
Visual Studio developers can bind their databases tightly to Windows form on a desktop or in a browser,
greatly reducing the cost of application development.
Most modern 4GLs produce 3GL scripts 'behind the scenes' as 'designer generated code'.
Every clicked or dragged object sets the result into 3GL code while the programmer
drags/drops, sets properties, and otherwise groks the IDE.
Some 4 GLs are Visual Studio.NET, Java Net Beans and Enterprise Net Beans, Oracle Developer, SB+, PowerBuilder,
IBM's AS400/i5 WebSphere, Eclipse, Enterprise Architect, Zend Studio, and several other 4GL operating environments
are involved in today's IT legacy. Applications developed with these tools can easily compete with Vertical Market providers
and continue to make 'grown here' or 'in house' solutions attractive where there are talented developers available.
4GLs provide objects built for interface with users, forms, databases, transactions of all types,
web services, and automate many other tedious programming tasks for transaction processing or EDI.
Today's 4GL developers use GUI drag/drop to do most programming tasks, and can focus on business rules and
improving the user interface rather than inventing code for each element of the UI for each project.
4GLs 'make the computer the programmer', writing 3GL scripts as the developer uses the GUI.
When it's time to distribute the software,
the 3GL scripts are
compiled to binary executable files in a traditional environment, byte code for middleware like Java or .NET, or,
interpreted for 4GLs that code PHP, Python, or other interpreted language.
- Middleware like JVM/JRE, Microsoft's .NET Framework, or IBM's SLIC runs the 'byte code' compiled for the
middleware and passes it to the executive. Byte code allows a developer to keep the
source code away from the customer by distributing only the byte code, sometimes
'obfuscated' to thwart customers' attempts at 'reverse compiling' the application's code.
- Interpreted Languages: Open Source Software is distributed as 'open source'
scripts are 'interpreted' by an 'interpreter' like PHP,
Perl, Ruby, or Python. With open source software there is no binary 'compiled code' or 'byte code'
to obfuscate a customer's view of the source code, so this is not a good way to write applications
that will be sold!
The interpreter reads the source code and puts binary code to the OS Executive practically 'a line at a time'.
They're able to store and handle functions and reference libraries of code.
While noticeably slower than traditional compiled code in the old days, modern interpreters are very quick,
lightweight, scale well, and provide a high degree of 'platform independence' because the interpreters have
been adapted to RISC, CISC, IBM i5 & zOS, Windoze, and *ix.
Interpreted languages like PHP, Python, or Ruby are easy to integrate with web servers like
Apache for Linux or IIS in Windoze servers. IBM was delighted to be introduced to PHP,
worked with Zend to deploy it native on i5 and z/OS...
Machine Cycles - Little Man Computer
(On your own)
Little Man Computer
exercise: Machine cycles, instruction set and
otherwise expand on the text. First mention of Data Structures, static in RAM of the LMC.