jump to navigation

The evolution of computing practice as reflected by programming languages. December 18, 2017

Posted by mmcmunigle in Programming Languages.
add a comment

This course provided a diverse overview of programming languages extending from the 1950’s through more modern concepts such as object oriented programming. We started our journey with some of the earliest programming languages that gave us high level languages that were quite dependent on the hardware machines they were running on.

Early Programming Languages:

It is interesting that each of these early programming languages had their own unique purpose and group that was driving them. They seemed quite independent of each other and were not necessarily trying to compete in their usage and features.

FORTRAN was one of the very first languages to have a formally defined grammar, and, along with other early languages, became known as general purpose high-level language. The focus of FORTRAN was primarily around mathematical and scientific computation. It was extremely successful and has been an important language for decades after it’s creation.

The next high-level programming language to come along was LISP. LISP was developed as a practical mathematical notation for programs. LISP was designed to work with an IBM computer to support programming for artificial intelligence research. A newer machine was eventually developed specifically for Lisp that had more power and memory for artificial intelligence programming.

The third early high level language that we researched, Cobol, was created for business use. It was created to help businesses efficiently handle large amounts of data. It’s development was influenced by multiple groups including the US Department of Defense.

General-Purpose Programming Languages:

While it was presented in the group of general-purpose languages, ALGOL is often considered part of the main four high-level languages with FORTRAN, LISP and COBOL. ALGOL gets it’s name from being an algorithmic language and looked to address some of the problems that existed with other languages at the time, such as FORTRAN. ALGOL has been a big influence on many other languages including C. I have the most experience working with C. I started with assembly, then transitioned to C so I have plenty of experience with the low level register/memory management. Much of C’s continued success today is due to it’s use as an implementation language for UNIX. It is a very efficient language and but may not be suitable for large scale systems. Later C++ will be discussed which is an extension of the C programming language.

PL/1 was another general purpose language that included concepts such as recursion and linked data structures. It was developed to be compatible with current and future hardware by having no reserved keywords and allowing hardware independent data types. However, it did not have the same long term adoption and success as C.

Programming Language Research:

Out of our programming languages we studied there were some very unique languages with their own purpose and implementation. SIMULA stuck out to me due to it’s use of object oriented programming and simulation package. Based on AGOL, Simula had a goal to be human readable and easily understood as a process description. We explored a few different simulation examples and I was impressed with the OO features and coroutines’s that were used in Simula.

APL is unique in terms of it’s development because the stakeholders did not worry about hardware, and instead were free to focus on the language itself. This is quite the opposite of some of the earlier languages we looked at where the machine architecture drove a lot of the teams’ development. Once there was sufficient/compatible hardware for APL, the language became popular for mathematical programming and using a special character set.

The other languages in this set introduced topics such as grouping sets into units (Modula), automatic type assignment and type safety (ML), and lazy evaluation (SCALA). To me, I find it amazing that these development groups are willing to spend so much time and effort into creating a “new” or “better” way to solve their problems. I’m sure it would have been much easier to use an existing language and work with what was available, but their vision and implementations led to all of the amazing features and efficiencies we take for granted today.

Object Oriented Languages:

Out of the three Object Oriented languages I have the most experience working with C++. C++ is an extension of C and tries to retain it’s simple design and efficiency in compilation. In contrast, Java was developed from the ground up to be an object based development language. The most interesting part of Java is that it runs in a Java virtual machine allowing it to be executed on any machine. C++ needs to be compiled for a target platform using a specific set of libraries. Another difference is that Java and Smalltalk include automatic garbage collection where C++ does not depending on how the objects/memory is created. Smalltalk is loved by it’s loyal users, placing second in the “most loved programming language” Stack Overflow 2017 survey. Smalltalk provides great flexibility in interactions between objects since everything is considered an object.

Education Languages:

Programming education is a topic that I am somewhat passionate about since I did not have any exposure in my schooling/club actives until I went to college. I believe it’s important to expose everyone early on in their school to programming concepts. Not only will this help the computer science community, but I believe it helps with a lot of other skills such as problem solving, organization, creativity and optimization. LEGO appears to be a cool solution to getting students excited about programming by using something that they are already likely familiar with. This is a great innovative way to teach a difficult topic using interactive methods other than a just a typical computer.

Dartmouth wisely realized that it wasn’t just computer scientists that should understand programming basics, but the managers and business focused individuals need to as well. However, learning a typical programming would be too complex and time consuming. To solve this problem BASIC (Beginner’s All-purpose Symbolic Instruction Code) was developed as a high-level programming language that focused around ease of use.

Pascal is more of a traditional programming language influenced by ALGOL. It focused on being efficient in compilation and runtime while being useful for teaching students structured programing. Pascal ended up being very popular language in the 80’s and early 90’s but eventually it’s shortcomings prevented it from continued popularity outside of teaching.

 

Advertisements

An Examination of the Evolution of Programming Languages December 17, 2017

Posted by cullin1 in Programming Languages.
add a comment

When examining the programming languages discussed during this semester, it blows my mind how far we have come in such a short amount of time. The first languages that we discussed, FORTRAN, Cobol, and LISP, as well as some of the other we looked at, were developed in the 1950’s. That’s not that long ago, so it’s interesting to see such advancement in such a short amount of time and makes me excited about what can be developed in the future.

As stated earlier, the first languages we examined were FORTRAN, COBOL, and LISP. Each of these languages was developed to combat a specific issue. Developers were looking to make programming “very much faster, cheaper, more reliable”[1]. FORTRAN was developed for scientific/engineering purposes, COBOL was developed for business, and LISP, designed for mathematics. They all have greatly influenced the development of later all-purpose languages, but are still used in their perspective areas. One of the creators of LISP, John McCarthey, points out, “LISP still has operational features unmatched by other languages that make it a convenient vehicle for higher level systems, for symbolic computation and for artificial intelligence”[2]. These three languages lead into our next few languages, which were not as problem specific and more general in purpose.

ALGOL, an imperative language used for algorithm description, was the “first programming language that gave detailed attention to formal language definition and, through the Algol 60 Report, introduced Backus–Naur form, a principal formal grammar notation for language design.”[3]. Although not commercially popular, ALGOL is used by many who are interested in the study of programming languages. ALGOL’s influences include many of the other imperative languages we examined, PL/1, Simula, Pascal, and C.

C is a programming language, designed to be compiled using a relatively straightforward compiler, to provide low-level access to memory, to provide language constructs that map efficiently to machine instructions, and to require minimal run-time support [4]. C is widely popular and is used in many places. PL/1 is also widely known, mostly for its features. These features include multitasking, the introduction of exceptions, and a set of control statements that were both flexible and powerful, like if-then-else statements, etc. [5].

After examining these three languages, we next looked at MODULA, which was influenced by Pascal, which was influenced by ALGOL [6]. MODULA was interesting for what it left out of its programming language. The topic of “garbage collection” or automatic memory management was discussed in during the examination of a few of the languages we examined and it was interesting to see the differing opinions on the function. MODULA left out “garbage collection” from its programming language because that programmers themselves were better storage managers, that would make the most of the, at the time, limited memory size [7]. Second, that these “garbage collectors” could activate themselves at unpredictable times, which could negatively impact real-time performance. Finally, that the security for the “garbage collection” was virtually impossible and that the “flexibility of the language had become its own impediment”[7]. All very well articulated points about the negatives of automatic garbage collection, and MODULA is not the only language that excludes it. We also looked at C and C++, which have manual memory management. On the other hand, LISP, APL, BASIC, ML and Java, have automatic memory management or “garbage collection” for “reducing programmer workload and preventing certain kinds of memory allocation bugs” [8]. It’s an interesting debate that has developed over the creation of many programming languages.

Our next set of languages are object-oriented, “a programming paradigm based on the concept of “objects”, which may contain data, in the form of fields, often known as attributes; and code, in the form of procedures, often known as methods” [9]. These concepts are found in many of todays programming languages. These languages include Simula, SCALA, Smalltalk, C++, and Java.

Obviously there are many programming languages that we could not cover given the length of the semester. I am new to the world of computer programming and had very limited exposure to languages prior to this course, my only exposure being introduction to Python courses. I have learned quite a lot about how programming languages, and their development, have evolved over the past 70 years or so. I have read about some of the good, some of the bad, and the some of the questions that developers and researchers deal with, even today, in programming languages.

[1] – Jan Lee, John Bachus, George Ryckman, The History of FORTRAN I, II, and III

[2] – John McCarthy, Lisp Session, History of programming languages I

[3] – https://en.wikipedia.org/wiki/ALGOL

[4] – https://en.wikipedia.org/wiki/C_(programming_language)

[5] – Ritchie, Dennis.  “The Development of the C Language.”  ACM SIGPLAN Notices, March 3, 1993

[6] – https://en.wikipedia.org/wiki/Modula-2

[7] – http://www.inr.ac.ru/~info21/pdf/Modula-Oberon-June-2007.pdf

[8] – https://en.wikipedia.org/wiki/Memory_management

Programming Language Evolution December 17, 2017

Posted by tareiter in Programming Languages.
1 comment so far

Programming languages certainly have gone through an incredible evolution process since their early inception.  It is something that I suppose I was aware of, but never really took the time to specifically think about.  After going through this class and being introduced to some of these earlier languages and moving forward through time, it truly is remarkable to see how things have progressed.  This is an area that started from almost nothing, and grew into something that is deeply ingrained into our world today.

We started things out by looking into a few of the earliest programming languages.  These included FORTRAN, COBOL, and LISP.  It was interesting to note that these early languages were often created by groups of people working together to accomplish certain goals.  The people in these groups included more than just developers, and also included people involved in various parts of the business process.  Those people were a valuable part of the team because these early languages were usually designed for special purposes and the completion of specific tasks.  It was at this time period where hardware limitations were most apparent, and the teams were presented with significant obstacles to overcome.

After looking at these earlier languages, we then moved on to General-Purpose programming languages.  As the name implies, these were more geared towards general usage rather than performing specific kinds of tasks.  In this section we looked at ALGOL, C, and PL/1.  ALGOL was another language that was created by a committee, but differed in that the group consisted only of computer scientists.  This language was created to write algorithms, and it strongly influenced future languages.  C is one of the most used programming languages of all time, and is still used today in some areas.  Finally, we looked at PL/1.  This was intended to be used for creating apps in the IBM mainframe.  Perhaps the most interesting thing about this language is that it contained not reserved keywords at all, which is very unusual.

The class finished out on looking at research languages, and object-oriented languages.  I thought it was interesting to note that with the research centered ones, they sort of went back to being designed for more specific uses.  Object-oriented languages were the only ones that I had any real familiarity with before this, so I found it fascinated to go along this journey and see how things got to where they got today.

At the end of all this I gained a lot of valuable insight at how programming languages have evolved since their beginning.  This is something that I will remember going forward, and appreciate as I journey further into my career.

Evolution of Programming Languages December 17, 2017

Posted by kenyonm1208 in Programming Languages.
Tags: ,
add a comment

This semester we’ve reviewed multiple programming languages of various backgrounds, as a fairly inexperienced programmer these weekly reviews provided me with invaluable knowledge on the origins of some of our most prominent computer programming languages. Through our time together I have come to realize that these languages were created in variety of different methods, but the common thread between these languages is there conception out of necessity.

It was during the late 1950s that programs languages like Fortran, Lisp, and Cobol set the precedent for languages of the future.  These three programs helped alter the state of computing from theoretical to practical due to their increased capabilities; whether it was Fortran with the first implementation of a formally defined syntax that described the rules and semantics, or Cobol which played a significant role in steering the primary use of computers at the time toward business applications, and of course we cant forget Lisp which popularized features like conditionals, tree data structures, and automatic storage management.

The previously mentioned programs were all designed with specific goals and industries in mind; with Fortran it was scientific computing, cobol was oriented towards business computing, and Lisp’s target audience was symbolic computing; as time passed we saw a shift from programming languages that were industry and hardware centric to general purpose programming languages. Moving away from a period where hardware specifications determined language quality and features.

Lastly we covered what most consider the most significant era of programming languages, Object oriented. Today object oriented programs have become the norm and almost all new programming languages implement object oriented concepts. A few of the languages that contributed to this period include C, Algol, and PL1; together these programs are none for their move toward portability, enterprise classes, efficient storage management  and of course abstraction . Today it is beyond evident that these programs had a lasting impact on the evolution of computer programming languages and future languages to come.

The Rich Library of Computing Languages December 17, 2017

Posted by hding22 in Programming Languages.
Tags:
add a comment

By Hong Ding

Before taking this course, I had little knowledge about the history of computing language and its rich varieties. I know there is a language called Python mainly for data manipulation and artificial intelligence. Java and C are big names I heard here and there but no clue what they can do. This course broadens my vision in how languages in computing area emerged and evolved and the behind-scene reasons for their blossom.

 

Although there are so many languages occurring in not-so-long computing history, most of them will and some have declined in popularity as time goes by. For example, as one of earliest languages, COBOL is developed by a commercial committee to tackle large data and information. It was once widely used in banking and financial industry and now mostly exits in legacy applications. [1] One of my friends who currently works in Fiserv, a technology provider for financial service, told me that some programmers still maintain legacy applications using COBOL. However, more and more experienced COBOL programmer retired and not many new programmers are willing to deal with COBOL anymore.

 

Even though many languages will lose its dominant status in the near future, many of its design concepts and characteristics will be merged in new languages. A similar analogy could be drawn with the language Latin, which was considered the crucial tool for literacy in much of the Europeans history and has developed many variants, yet now remains a dead language and only was used limitedly in Catholic Church. However, the legacy of Latin is prevalent in Romances languages. [2] The same is true with many computing languages. For instance, ALGOL is a high-level language most used by research computer scientists in the United States and in Europe. It is not successful in commercial application but later influenced many other languages especially in its lexical and syntactic structures and “virtually all languages designed since have been referred to as “ALGOL – like”. [3] Likewise, Smalltalk is not as popular as Python, Object C or Java nowadays, but its features are reflected in those languages. [4]

 

To sum up, the vicissitude of computing languages should be regarded as a normal pattern due to the rapid-changing environment of computing community per se. Yet, the ingenuity of design and other rich legacies of those languages will carry over.

References:

[1] https://en.wikipedia.org/wiki/COBOL

[2] https://en.wikipedia.org/wiki/Latin

[3] University of Michigan, The ALGOL Programming Language, 24 November 1966, available on line at http://groups.engin.umd.umich.edu/CIS/course.des/cis400/algol/algol.html on 22 September 2017.

[4] https://en.wikipedia.org/wiki/Smalltalk

Thoughts on how and why programming languages evolve December 17, 2017

Posted by sarahgraupman in Programming Languages.
add a comment

As I reflected on everything I learned about programming languages this semester, I realized there was something missing. I couldn’t put any of this into context. The articles I read gave me a good understanding of the theories and motivations behind these programming languages, but I didn’t understand how they were used and what the people who use/used them thought. I’m lucky to work with a talented group of software developers and computer scientists who are willing to take time out of their day to share their opinions. After sitting down with others and discussing the list of languages covered by this curriculum, I started to get a better understand of how and why programming languages have evolved.

After several discussions with programmers of varying experience levels, I began identifying different drivers for language evolution. I had conversations about how different programming paradigms, like imperative, object-oriented, and functional, created different needs. I learned from my readings and talks that there were many ‘paradigm pure’ languages that were created to prove the validity of these concepts. Many of these were not widely adapted of practicality restrictions. Smalltalk may have been too strict in its implementation of the object-oriented paradigm. LISP and APL were too hardware dependent to be widely adopted. This doesn’t mean that their contributions were not valuable, though. For example, LISP many not have been widely adapted but created a clear split between imperative and functional programmers that can still be seen today. I quickly learned this wasn’t the only matter on which programmers had different opinions.

The amount of constraints a language puts on a programmer was a large topic of conversation in my discussions. Some languages like PASCAL put strict limitations on what a programmer can and can’t do. This makes a lot of sense for a teaching language that wants to ensure students are indeed doing what they intended. On the other hand, C is not very restrictive to its users by giving programmers the power and responsibility to manage their own memory. This may be part of the reason why C has seen such wide and long-term adaptation. This style does not work for everyone though. Evolution and pushback of these ideas can be seen through the development of C++ and Java that put stricter limitations on C.

I also realized the importance of typing in programming language evolution. There has been progression from the strict typing of FORTRAN and PASCAL to more dynamic types like Smalltalk. One of our software developers noted that there are also many languages that fall in the middle of these extremes like ML and SCALA that have type inferences. The importance of typing wasn’t something that I thought much about before, but I now realize there are many small differences between programming languages I may not have thought of before that can make them drastically different from each other.

I learned that programming languages come in all shapes and sizes and for good reason. Some languages are very good at handling specific problems, like SIMULA’s discrete event simulation abilities. Yet others strive to wear many different hats, like ADA which attempted to be the last programming language needed in that it could do anything. Another example of this would be Python which has been said the be “the second best language for any problem.” Some strive to be easily readable, like COBOL, while others focus on being efficient to write, like APL which could code up Dr. Corliss’s entire dissertation in 40 key strokes. There are languages like ALGOL that were built by committees, and there are languages that were built by one or two individuals like C.

After a semester long journey through a small subset of existing programming languages, I have learned about any different philosophies about programming that have and are still being formed. I don’t think there will every stop being new programming languages being created and developed. The programming community is never going to come together and converge on one best language that fits everyone’s needs. Programming has grown and continues to grow so rapidly that there are always going to be new ideas and problems that cannot be solved adequately with current languages. There are going to be strengths and weaknesses in every language and every programmer. It’s up to companies, schools, individuals, etc. to pick a language or languages ,whether brand new or from the 1950’s, that best suits their needs.

 

 

Sources:

Sammet, Jean E. 1981. “Paper: The Early History of COBOL.” History of Programming Languages(Academic Press, Inc.

Dennis Richie – Development of the C language

p47-iversion(APL).pdf

B, Stroustrup. The History of C++: 1979-1991.

https://en.wikipedia.org/wiki/Scala_(programming_language)

https://en.wikipedia.org/wiki/C_(programming_language)

 

 

Thank you to Dr. Corliss, Nathan Wilson, and everyone else at GasDay who contributed their thoughts to this post.

A Concise Overview of Programming Language History December 17, 2017

Posted by supcl in Programming Languages.
add a comment

Programming languages—if the length of their history were compared to that of humankind’s, we would consider them a young platform of human to machine communication.  On the other hand, if compared to the history of computing, we can acknowledge that they’ve been present since the beginning.

For almost 70 years, programming language development has been distinguished by dynamic growth.  The first appearance of a programming language occurred in the early 1950s in the form of assembly languages.  Naturally, this closely coincided with the creation of some of the first modern computers.  Due to limitations that existed with early incarnations of computers, programmers were required to provide machine instruction in methods that opposed the concept of modern programming language abstraction.  In this same decade and the following, advancement in programming languages became prominent as the first high-level programming languages were developed and released for use.  This new classification eased programming functions by making them more human readable and introducing automated functions.  In addition, this period presented block structuring, encapsulation, and algorithmic instruction sets that tend to be more familiar as aspects of modern languages.  Some of the most impactful programming languages that introduced these concepts were FORTRAN, ALGOL, COBOL, APL and Simula.

The major concepts and models that future programming languages would follow were substantiated from standards set in the previous decade (some mentioned above), deliberations that would follow in the late 60s and 70s, and the elaboration of those concepts in languages released in that timeframe.  In this period, the value of structured programming was confirmed by propagating the need for logic-based control structures and modularity in programming languages.  Object-oriented programming truly began to take its place in the programming world through implementations such as Simula and Smalltalk.  ML made contributions to static typing and its declarative nature, as well as polymorphism—being a way to use the same interface for differing data types.  In the 80s, languages introduced further elaborated on the standards developed previously.  These concepts further spread by developing languages and progressing concepts that would be used on complex and extensive systems.  A notable language implementation at this time was C++ which has contributed greatly to operating system development and management.  By the 90s, profound changes would occur to the breadth of computing platforms and how “end users” would interact with those systems.  The concept of functional programming would be expounded and be essential to increasing programming efficiency and reaching the requirements of more modern programming projects.  Like in Python and Java, functional programming meant implementing higher-order functions (calling a function in another), recursion (functions calling themselves until a base case is achieved) and promoting greater levels of encapsulation and modularity.

Presently, programming languages continue to be in a constant state of evolution.  As platforms continue to improve and requirements consistently grow, so will the capabilities and aspects of programming languages.  Functional programming seems to be the current way ahead, but the challenge remains on how to scrupulously apply its methods to emerging trends; furthermore, these trends are determined by the needs of individuals and organizations that are customer to services created by the progression of programming languages and the platforms in which languages interact.

Computing History December 17, 2017

Posted by kevinmea in Programming Languages.
add a comment

The evolution of computing practice as reflected by programming languages.

 

The evolution of programming language was not evident to me until I took this seminar.  Even after this seminar, this topic is so large that I feel we have only scratched the surface.  After spending a semester learning about the history it is clear that programming has come a long way from Alan Turing to the latest cutting edge data science tools.   I will look at three languages briefly to try to walk through some history of programming.

 

We started this semester looking at languages like Fortran.  Fortran is a general purpose, imperative programming language that is especially suited to numeric computation and scientific computing. [1]  This language was developed in the 1950’s by John Backus for mainframe computers.  The language included basic programs composed of blocks and made use of IF statements and other numeric calculations.  Fortran also provided support for procedural programming by introducing statements which allowed programmers to create subroutines and functions, thereby encouraging the re-use of code.  [2]  This allowed programs to grow in complexity and allowed programmers basic control of procedures and efficiency.

 

We looked at the C language next.  C is a general-purposeimperative computer programming language, supporting structured programminglexical variable scope and recursion [3]  Most people like to say that C is close to the machine.  In 1985 Windows 1.0 was released. Although Windows source code is not publicly available, it’s been stated that its kernel is mostly written in C, with some parts in assembly. Linux kernel development started in 1991, and it is also written in C. [4]  Those are two of the largest operating systems out there.  One for enterprise and one for open source.

 

Finally, I investigated the Python language.  Python is a widely used high-level programming language for general-purpose programming, created by Guido van Rossum and first released in 1991. An interpreted language, Python has a design philosophy that emphasizes code readability (notably using whitespace indentation to delimit code blocks rather than curly brackets or keywords), and a syntax that allows programmers to express concepts in fewer lines of code than might be used in languages such as C++ or Java.  [5] Python is used to program popular applications like Dropbox and Eventbrite.  Python is popular for concise code and is used extensively for data science purposes.  Since data science has overtaken analytics and is the growing trend, so is Python.  Data science is now a huge field covering everything from data collection, cleaning, standardization, analysis, visualization and reporting.   One of the most popular data science libraries is Pandas for Python.

 

 

References:

[1] https://en.wikipedia.org/wiki/Fortran#History

[2] https://www.obliquity.com/computer/fortran/history.html

[3] https://en.wikipedia.org/wiki/C_(programming_language)

[4] https://www.toptal.com/c/after-all-these-years-the-world-is-still-powered-by-c-programming

[5] https://en.wikipedia.org/wiki/Python_(programming_language)

[6] http://dataconomy.com/2016/10/big-data-python/

The Evolution of Programming Languages and Navigating the Landscape Today December 17, 2017

Posted by bodenburgmarq in Programming Languages.
add a comment

One thing is for sure: collaborative open source environments has increasingly enabled more and more programming languages to be developed and maintained with the goal of improving a developer’s life. Today, it may seem like we cannot go a month without hearing about a new programming language gaining popularity and claiming to be the one we need to learn and use next. When hearing about a newer programming language today, the description usually involves keywords like “easy”, “flexible”, and “efficient”. This seminar has shown that programming languages of the past are extremely influential to their successors, or, to put more accurately, derivatives. Programming languages provide both trade-off advantages and disadvantages depending on the application and also become a benchmark to new languages being developed that proclaim to be are easier, more flexible, and more efficient. The evolution of programming languages has brought us to place where not only older, more traditional and “mainstream” programming languages are sought after, but the new languages that leverage their predecessors’ traits and paradigms as well.

The aim of making a programmer’s life easier was apparent years ago with some of the first high-level programming languages that became widely used. For instance, FORTRAN and ALGOL were some of the first programming languages that had a defined formal grammar. This enabled programmers to learn and know what syntax constructs were valid. COBOL, another early programming language, aimed to create a more-readable syntax (which also brought verbosity) for business users. These languages are well known for their intended purposes (i.e., scientific computation for FORTRAN and ALGOL, business applications for COBOL), which limits their flexibility in application. So, it could be argued that the next wave of programming languages aimed to bring flexibility and intention of being used for a wider variety of application.

Later on, general purpose languages, like C, arose which made efforts to be more generic and flexible. They intended to be the primary tool for processing data, numerical computations, and writing system applications. For C, efficiency arises from its low-level capabilities and data structure handling such as pointers and arrays. Furthermore, to add to its flexibility, C was a cross-platform language and able to be run on different operating systems. Where FORTRAN and COBOL are still being seen today because of legacy constraints, the flexibility and efficiency of C are more likely why it is still popular and being seen today.

Object-oriented languages then began to gain traction. This could be due to how a human views the world: through objects. SIMULA, a programming language geared towards simulation, is considered one of the first object-oriented languages and used programmatic objects to model real-world objects[4]. The object-oriented nature was also blended with C to influence C++, another popular language today, especially commercially[5]. Java, a popular first programming language to learn, maybe where a programmer first learns about inheritance and polymorphism. Memory management and garbage collection are also strengths of Java, making the life of a programmer easier. For the most part, there is no need to worry about managing an application’s memory since it is all being done automatically behind the scenes.

So, as of today, where do you begin picking a new language to learn? After learning about the history and evolution of programming languages in this seminar, I know one thing for sure: there is not one best programming language for all scenarios. When asked what the best programming language is, a well-versed programmer should respond with, “it depends”. For a home improvement project, would you pick a hammer or a screwdriver? Well, it depends. When tasked with a project, a programmer should weigh the tradeoffs when selecting a language to use (and learn!) – which can even span multiple ones. An appreciation of the history and evolution of programming languages can help aid the decision in what language to use, understand the language’s basis for improvement upon predecessors’ pain points, and enjoy the successes that are incorporated and built upon as well.

Sources
[1] https://en.wikipedia.org/wiki/Fortran
[2] https://en.wikipedia.org/wiki/ALGOL
[3] https://en.wikipedia.org/wiki/COBOL
[4] Dahl, Ole-Johan & Nygaard, Kristen. “SIMULA – an ALGOL-BAsed Simulation Language”. Programming Languages.
[5] Stroustrup, Bjarne. “A History of C++: 1979-1991”. C++ Session.

The Evolution of Computing with Programming Languages December 17, 2017

Posted by vsewa in Programming Languages.
add a comment

     The evolution of programming languages has changed over the years from programming in binary set of instructions of just 1’s and 0’s to high-level abstract programming languages that removes the programmer from managing the low-level hardware programming. Throughout this semester, the journey through the history of programming languages was very enjoyable to learn. From the beginning of FORTRAN to the recent languages such as Java. In the 1950’s FORTRAN was the first high-level programming language developed at IBM by John Backus. The goal was to remove the programmer from writing in assembly or machine language that was so common before high-level programming. FORTRAN and automatic programming led to favorable economics and productivity by reducing the amount of man hours and debugging time spent to run programs. According to the paper, programming and debugging accounted for more than 3/4th of the cost of operating a computer and as computers became cheaper to produce this problem got worse in terms of cost. FORTRAN during the early developments was not carefully designed to be a structured organized programming language, John Backus was more concerned on the compiler (translator) to provide efficient programs rather than on the language design. FORTRAN was commercially successful both to businesses and academia. It helped influence many other languages.

     Following FORTRAN came the language of COBOL. This language used many ideas from FORTRAN but was tailored for the business end-user and less scientists and engineers. Businesses began to use computers and became the primary users of computing, COBOL was very easy to read and understand because it used English language as the foundation for the code. COBOL helped create the definition of database management. COBOL has had many contributions to the computing community. The two that were mentioned greatly were the contributions of a meta language to describe the programming language and the concepts that paved the way for Database Management Systems (DBMS) with COBOL’s separate Data Division that allowed one data description to be used for many applications. One goal that was truly accomplished by the committee was creating data processing language that was easily readable using the English language. I believe COBOL is very easy to read based on my own research in the language and reviewing some basic source codes from the internet. Interesting to note that still over 70-80% of the lines of codes ever produced is in COBOL much due to the implementation in mainframes and many business companies. Along with contributions to meta language and DBMS, COBOL also contributed to a machine independent language that helped make the language portable based on the limitations of the hardware at the time. COBOL is still in existence today after over 58 years and still maintained and updated with new lines of code and that truly speaks to the great achievements of Jean Sammet and the rest of the team for their contributions in a powerful business oriented language. At the time, the state of computing during the late 1950’s and early 1960’s had many limitations of hardware and machine dependent compilers.

     By the 1960’s LISP was developed for the field of Artificial Intelligence (AI). The introduction of LISP allowed for list processing and influenced the IBM 704 by the subexpressions car and cdr which stands for “Contents of the Address Register” and “Contents of the Decrement Register” respectively. The motivation for implementing car and cdr separately was strengthened by the vulgar fact that the IBM 704 had instructions (connected with indexing) that made these operations easy to implement.

     After the beginning of the timeline of the 3 major programming languages FORTRAN, COBOL, and LISP came the GPL (General-Purpose programming Languages) such as ALGOL, C and PL/I. This programming languages were created to handle general problems of any kind and began to help define the design of data structures. These languages were all used in computing on the commercial side, with C being the most successful as it is still used today heavily in embedded system design and programming. Next came the field of programming language for research purposes and the languages of MODULA, ML, APL, SCALA, and SIMULA were discussed. These languages were more modular in structure and allowed easier programming and abstraction then compared to the programming languages back from the early 1950’s. The creation of modules supporting abstraction and specification helped lead to modern programming languages such as JAVA and other OOP languages. OOP (Object Oriented Programming) languages are the most common programming languages used today starting back with SMALLTALK then C++ to follow and JAVA shortly after. OOP allowed for more flexibility for the programmer in allowing to create objects which can represent anything and used in data structures. It helped automate memory management and automatic garbage collection, which were things earlier programmers were responsible for during past programming languages such as C for example. Lastly the languages of education were developed such as LEGO, BASIC, and PASCAL. The language BASIC was an acronym for Beginner’s All Purpose Symbolic Instruction Code. It was developed by Dartmouth mathematicians John Kemeny and Thomas Kurtz as a teaching tool for undergraduates. BASIC was intended to be a computer language for generalists to use to unlock the power of the computer in business and other realms of academia. BASIC was traditionally one of the most commonly used computer programming languages, considered an easy step for students to learn before more powerful languages such as FORTRAN. Until very recently, BASIC (in the form of Visual BASIC and Visual BASIC .NET) was the most widely known computer language among developers.

REFERENCES

[1]       https://d2l.mu.edu/d2l/le/content/328978/viewContent/2171690/View

[2]       https://en.wikipedia.org/wiki/C_(programming_language)

[3]       https://en.wikipedia.org/wiki/BASIC

[4]       https://en.wikipedia.org/wiki/Programming_language

History of Programming December 17, 2017

Posted by kgrif414 in Programming Languages.
Tags: ,
add a comment

The history of Programming languages

Many light years ago in a small town in England a Charles Babbage proposed a machine he called the “analytical Engine”. In 1843 Ada Lovelace a mathematician and writer had a break through while transcribing the memoirs of a military mathematician by the name of Luigi Menabrea. Ada a teenager corresponded with Charles Baddage for years to come while he was developing his proposed idea. While working with Baddage, Ada developed the first algorithm that would enable Babbages Analytical Engine to calculate a sequence of Bernoulli numbers. For her documented achievements she is often described as the first computer programmer.

Over the past months my cohort`s and I have been in constant discussions and enlightened thinking about the history of what is known as computer programming. Now for me this has been an interesting couple months, a Powershell scripter by trade I have dabbled a little in programming. To see the state of computer programing today and to be involved in the grass roots process of the past I am sure was an honor for a couple hundred dedicated individuals from far stretches of the globe. What I have learned from the history of programming is that collaboration and documentation is key, sprinkle in a healthy dose of competition makes for the best recipe to push any process or industry forward. The evolution of Programming has endured years of direction changes, dead-ends and trial and error. With many players and stake holders trying to influence and contribute ideas and at the same time be forward thinking.

The code in the early years of programming was more like a hobbyist practice than a legitimate source to run computer routines. Often using no English language in the code just computer language which was read from punched cards or magnetics tapes and toggled switches. In the early to mid 1900 we start to see an uptick in computer code. Many students, hobbyist and university members trying to design and create languages for computer use. Then in 1954 IBM created a language called FORTRAN it soon became the most widely used language of it`s time. Fortran was the first physical functional language compared to theory or design on paper. This language gave the computer industry a boom in the computer market with advances and knowledge doubling throughout the years.   Other languages soon followed like Cobol. The brain child of many US companies funded by the US government. Cobol was created because many invested member wanted to standardize the computer programming industry. Cobol was designed for the novice as well as the seasoned programmer`s in mind. Next in the long line of interpreters is LISP which used symbolic expression compared to using numbers in the computer memory. Recursive list was another one of LISP strong points. Today anytime you talk about computer programming.. Algorithms is what come to mind. Algorithms derived from the programming language ALGO a general purpose language which was the standard for Algorithms of the future. ALGO also brought about multidimensional array, coding syntax as well as block structure. Although it was not heavenly adopted in the US, ALGO was very popular in European countries. Programming has come a long way and is still today evolving.

[1]https://en.wikipedia.org/wiki/History_of_programming_languages

[2] https://en.wikipedia.org/wiki/Ada_Lovelace

[3] https://en.wikipedia.org/wiki/Luigi_Federico_Menabrea

[4] https://en.wikipedia.org/wiki/Charles_Babbage

[5] https://en.wikipedia.org/wiki/ALGOL

[6]https://en.wikipedia.org/wiki/ALGOL_60

 

Student : Kevin Griffin

MSCS 6390 101 Professional Seminar/Computing:

Professor : Thomas Kacmarek

Evolution of Programming Languages December 17, 2017

Posted by anatvera in Programming Languages.
add a comment

The modern world is changing more and more rapidly each year. We are constantly learning about emerging computing topics like Internet of Things (IoT), Big Data, Quantum Computing and Augmented Reality. These advancements have not only transformed the way humans communicate with each other, but also how we think about and communicate with the “virtual” world. This growing digital interaction has been possible thanks to the evolution of programming languages.

If we go back 70 years ago, computers were being developed for industrial and government applications. A machine-dependent language (assembly) was used to program them. Early developers had to spend considerable amounts of time solving hardware and low-level software restrictions, which became costly and difficult to support. These constraints motivated the development of FORTRAN; an easier to use machine-independent language developed to perform high-level scientific and mathematical formulas. This language got us closer to what early programmers described as “automatic programming” and introduced the first complete compiler in 1957.

Around the same timeframe, a larger group of people was working to develop a more uniform user-friendly language that could solve business-oriented problems. They came up with COBOL, a language that is still used in finance and administrative applications. Still to this day, I would say this it’s the most English-like language.

In the late 1950’s data structure and recursion concepts were introduced with the creation of Lisp. This language was specifically developed for the IBM-704 computer for Artificial Intelligence research. Because of different uses of Lisp, new dialects emerged. Nowadays, the most common ones are Commong Lisp and Scheme.

Up to this point in history, there was a close dependency between hardware and software. Later on, computer scientists started thinking of developing solutions that could be applied to multiple application domains. We call this category General-Purpose Programming Languages (GPL).

ALGOL was one of the first GPL. Although it wasn’t as popular as the previous languages, it highlighy influenced other ones such as Pascal, Ada, Simula and C. It also introduced important programming concepts such as dynamic arrays and block structures. ALGOL was the first language described in Backus-Naur Form (BNF), which is still the standard way of describing context-free languages.

As programming languages advanced, computer hardware did too. Processing power and memory rapidly increased over the years. This allowed programmers in the 1970’s to develop more complex algorithms. But for this, a more powerful and versatile language was required. This led to the creation of the C language.  About half a century after its creation, C continues to be one of the most popular languages in the world. I believe this language remains so popular because of its simplicity and ability to manually manipulate memory with a high-level programming language.

A couple of years prior to the release of C, a group of computer scientists were already thinking on multi-dimensional programming as a way of reducing program execution time. The PL/I language was considered one of the most innovative languages of the time and it introduced the idea of multitasking and shared data manipulation (using semaphores, mutex, etc). These concepts are extremely important today as the size of data handled by computers grows every minute.

In the next few years, practicality and simplicity were driving factors for the development of languages. At the end of this decade we see new languages with type inference such as ML and SCALA. Two other languages achieved practicality by encapsulating code into modules (Modula) or classes (SIMULA) which, in my opinion, simplified the understanding of variable scopes and inheritance.

These languages led to the development of what we now call Object-Oriented programming. We studied Java, C++ and Smalltalk. The first two remain extremely popular and were influenced by Smalltalk. C++ is a modification of C but it still preserved its powerfullness and versatility. Java is considered a safer and more reliable language as it detects runtime errors and manages memory with its built-in garbage collection (to avoid memory leaks).

This summary of the evolution of programming languages leads us to today’s world, a world where programming is not only for development of complex mathematical problems, but rather a tool that anyone can use to solve day to day problems through technology. Since the early days of programming, there has been efforts to facilitate teaching of code through easier languages. One of the first educational languages was Pascal, a small and efficient language intended to encourage good programming practices. BASIC, another simple language was specifically designed to attract different audiences to computers, not just mathematicians and computer scientists. Finally, there is LEGO, an innovative and creative method created to explain programming via LEGO bricks, and therefore, also applicable to younger audiences (K-12+).

It’s been a great experience learning about so many different languages, their history and their purpose. Like human languages, programming languages have evolved – some of them are almost extinct and some of them have survived decades. Dialects and new languages continue to emerge as new computing needs and technologies develop. The more we know about them, the more prepared we will be in the future.

Ana Vera

December 12th 2017

Dialect over syntax- as subtle change driver behind programming languages. December 17, 2017

Posted by Awebwa in Programming Languages.
add a comment

Introduction

We generally agree that programming languages were born out of the impracticability of creating computer programs by ‘directly’ using machine language. This early realization for the need of writing computer instructions in human readable language sparked off a computer revolution. Once the first language was written and the concept clearly understood, flood gates opened, and we see language after language. Every new language has a reason and sometimes referred to as a purpose. Every team that come together to come up with a new language advances reasons that are professional and intellectually composed.

Throughout my study of programming languages, one question that has been resounding is: “why another language?” Every preamble to the history of a programing language states and describes what the creators of the language thought was fundamental and would support a transition from the previous language to another and even consider their language as a purely new “kid on the block”. Reading between lines however, we discover that in many instances, there was a silent war between dialect and syntax, the effect of which would be a burst into another language.

The concept of syntax as borrowed from a natural language refers to the rules that are strictly adhered to while composing words, phrases and sentences. The structure of the languages and its grammatic rules.

On the other hands a dialect is a special phenomenon of the same language being spoken differently by two groups. Sometimes the variation is so small (progressive) while in other cases the difference is so sharp that one group can hardly understand the other even if they are speaking the same language. Dialects drive vernaculars and understandability of a natural languages.

Contention between syntax and dialect

Examining the history of programing languages brings out a contention between dialect and syntax in such a way that the side of dialect demanded simplicity, understandability and freedom of expression while the syntax side demanded standardization of language structures not only creating the correct grammar but the right symbols in the right places sometimes compounded by formats.

While emphasizing the objective of FORTRAN, John Buckus state that [1]

“we did not regard language design as a difficult problem, merely a simple prelude to the real problem: designing a compiler which could produce efficient programs. Of course, one of the goals was to design a language which would make it possible for engineers and scientists write programs themselves for the 704”

From the above statement, we begin to see the level of consciousness exhibited by language developers about their intended users. The language designers are faced with an enormous challenge to create syntax and rules which will not only solve the problem on the machine side but at the same time address the needs of the intended user. This in most cases is the origin of the tag of war between syntax and dialect as the users begin writing code, users will later present various facets of their problem.

ALGOL-Like, influence of language semantics and understandability

Developed for algorithm proofing and highly expressive, the development of ALGOL brings out the contest of syntax against dialect. While introducing the semantic model, Lindsey notes that:

“Any definition of a programming language needs to define very carefully the “domain of discourse,” or model, in terms of which everything is to be explained. “

On the failure of ALGOL 68, she remarks as well that [2]:

“The real question is why it did not come into more widespread use, and the answer here is simple enough: because it was not implemented widely enough, or soon enough. And the reason for that is that implementation was too hard, and the reason for that was because a relatively small number of trouble spots, not inherently necessary for the basic principles of the language and certainly not for its orthogonality. It was possible only to correct a few of these problems during the revision”

The above is another classic example where language semantics strongly influence the usability of the language. Of course, other factors such as machine dependence failed ALGOL, but the description of the language has a part to play.

Object “Orientedness”

SIMULA was developed to facilitate a formal description of systems that are composed of discrete process (Simulation) using the ideas we now know as object oriented. As a successor of ALGOL, SIMULA carried a good portion of ALGOL and one of the objectives of SIMULA was that the language should be easy to understand and should be able to describe the domain being simulated, a shortfall they attribute to FORTRAN and ALGOL [3].

C Language was credited for being simple to understand as a general-purpose language. It could be used to build anything and compiled and ported on cross platforms. Fair enough to say this was great. The language became widely used and as its usage expanded, its vocabulary sooner became thinner. Creative users started demanding lifting of restrictions to the rules.

The point we note here is that creative usage of a language sooner or later pushes it to the limit. Once users relate the language to their own understanding and their own domain they begin to push syntax boundaries. The success of object oriented languages such SMALLTALK, C++, JAVA is the fact that the code has a natural flow in the user’s mind when the object paradigm is used.

Special purpose Vs General purpose rates of change

General purpose languages(GPL) place a lot of user expectation in one language for anything. Reserve words begin to increase to accommodate demands of diverse usage, the style of writing including use of spaces and the criteria for code blocks as required by the syntax begin to inconvenience the creative language user.

Special purpose languages therefore, are designed to reduce user expectation by addressing a specific need. SNOBAL is a programing language for manipulation of strings [4]. While introducing PROLOG, David H D Warren and Luis M Pereira settle the user’s expectation too as follows [5]:

“Prolog is a very simple, but surprisingly powerful, programming language developed at the University of Marseille [Roussel 1975], as a practical tool for “logic programming”

Special purpose languages therefore are confined to a specific dialect and hence less likely to change at the same rate as general purpose languages.

Education purpose

Programing languages are used to teach computing concepts. Abstract concepts such as memory, program description, compilation, interpretation, loading, and execution are but a few of these concepts. Based on ALGOL, Professor Niklaus Wirth among other reasons developed PASCAL to facilitate teaching of important concepts in programming [6]. Until rivaled by object oriented dialects by C++, Visual Basic and JAVA, PASCAL had a large share as a learning tool.

In a learning environment, the syntax needs to be simple while enabling the learner to understand the concepts. Language semantics and dialect should fit the purpose as well. Java has been described as too verbose compared to Python.

One interesting approach was taken by LEGO [7]. The language uses a board and bricks without formal written syntax to teach programing concepts. This can be considered a dialect only approach.

Conclusion

Other than performance, hardware implementation and purpose of use, programming language revolution is silently pushed by the contention between language designers whose objectives are implemented by defining the grammar and rules – Syntax and the objectives of language users whose ingenuity leads to creative ways of using the language that later results into pushing the restrictions placed by the syntax. This contention sometimes results into language revisions and in other cases the creation of an entirely new language.

 

References

[1] History of FORTRAN I II and III p.30

[2] History of Algol 68

[3] SIMULA an ALGOL -Based Simulation Language (Ole-Johan Dahl and Kristen Nygaard Norwegian Computing Center, Oslo, Norway 1996)

[4] SNOBAL a string manipulation language, D.J. Farber, R.E. Criswold and I.P Polonsky of Bell Telephone Laboratories Inc, Holmdel New Jersey.

[5] PROLOG – the language and its implementation compared with lisp, David H D Warren and Luis M Pereira.

[6] http://groups.engin.umd.umich.edu/CIS/course.des/cis400/pascal/pascal.html

[7] Teaching Programming and Language Concepts using LEGOs, Cynthia S. Hood and Dennis J. Hood

An Evolution of Programming Languages by Dianne Williams December 17, 2017

Posted by williad7 in Programming Languages.
add a comment

The evolution of programming languages is a fascinating journey. How and why each language was created tells the story of courageous and innovative individuals would not accept failure, and were strong enough to stand firm when others disagreed. Amazing computing pioneers who through persistence, inspiration, and belief in themselves laid the foundation for where we are today. History is important. As Theodore Roosevelt said, “The more you know about the past, the better prepared you are for the future”. Throughout the course it became clear that the common thread that existed was that the environment of origin and the vacuum of need that existed at that time determines the creation of a language and how it is learned.

The early languages FORTRAN, COBAL and LISP, began to emerge in the 1950’s by allowing for advances heralded by increased data accumulation and analysis. Fortran was developed in response to scientific and engineering needs to drop time consuming and difficult machine assembly code, and to render math formulas into code efficiently and easily. FORTRAN was the first to develop a formal language. Like the first step on the moon, FORTRAN integrated algorithms and language to create a programming language. Although costly and slow it still proved to be an important research tool. Advanced versions of FORTRAN included “Boolean” expressions and other computational advances, yet widespread distribution was never achieved. COBAL was developed in response to a need for a common business language for automatic computers that involved both the user and the manufacturer. The needs then were not that different from needs expressed now, i.e., variations among computers, time and cost of reprogramming, and the ability to exchange among computers. COBOL has been usable for more than 20 years, due to remarkable contributions such as implementing the idea of data description that could be used to describe data for different computers, and separate from execution statements which in turn led to the conception of Database Management Systems! COBAL has rightly earned it a place in computing history, despite its inherent problems, it has brought together actual users along with manufacturers who were competitors together with a common goal. That goal resulted significant achievements for programming, and the development of a common business orientated language. LISP was largely developed in response to the desire for an algebraic list-processing language for AI research. LISP introduced several significant contributions to programming that remain with programming today. Garbage collection, the use of parentheses for pre-fix notation, recursive conditional expressions, compatibility with binary or assembly level production programs, and a LISP interpreter with a command language for other languages, are only some of the enormous LISP contributions. These early languages demonstrate the forward march of programming advances, that resulted in similar progress in computer architecture, and vice versa.

As computing progressed, the General-Purpose Programming Languages, ALGOL, C, PL/1, rather than operating in response to a specific problem, were created to handle a broad range of problems- a commercial focus. ALGOL was the result of several factors. In general, the esteemed computing minds of Europe felt the need for a common programming language, being aware of the development of FORTRAN in the US. ALGOL contributed important concepts that remain today in one form or another. It introduced code blocks, among many other significant contributions, and was the foundation that gave rise to Pascal, and C among others. ALGOL was the standard method for algorithm description used by ACM and other academic sources for over thirty years! Ultimately ALGOL was a difficult language to read, and fell victim to conflicts among programmers attempting to make it more than just a General-Purpose Programming Language, but its contributions remain an important part of programming history. The emergence of C began with the popularity of UNIX. In 1972 a significant portion of UNIX, a popular program at the time, was rewritten in C, thus C enjoyed the benefits of a popular platform. It is with this large circulation that additional attractive attributes were discovered on a large scale and garnered praise as well. In a general manner, remaining a simple, small, and understandable language that was portable across machines made C even more appealing. The popularity of C was based on quality. The value of its features are sustainable, real and enduring. C has remained an enduring language not because of initial popularity, but because of its ability to continue to create portable programs that do “useful things” in a simple and efficient manner. PL/1 was born of FORTRAN and COBOL parents, and is an imperative, machine independent programming language that is still actively used today, and for good reason. Although known for many significant features, its multi-tasking, on condition processing and interphase control are particularly impressive. PL/1 did not become the dominant language, however, it was a significant advance in programming languages of its time.

Programming language research continued to build on past advances and gave rise to Modula, ML, APL, and Simula, each introducing exciting developments. MODULA was designed to be efficient and reliable, and to communicate basic programming concepts as well as creating programs. MODULA maintained a commitment to concept clarity, and simplicity, notably omitted features considered necessary for very interesting reasons. As the computing environment become more advanced, important features are relied on to run reliably, and lending to efficiency, not taking away from. In the case of Modula, features that are routine today were viewed cautiously as possible agents of disruption due to the belief that ultimately programmers create their own unique specifications. The language of ML featured type inference and a strongly typed nature, able to create abstract data types with its approach to a fundamental element, the list. ML is a popular language for research and theorem proofs due to its simple, direct, and logical character. APL was developed in response to a need to evaluate, and explain areas in data processing, as well as being a teaching language. It featured mathematical grounded roots, and as such was widely used in functional programming, spreadsheets and computer math packages. APL became widely used, and influenced other languages we see today, such as MATLAB, J and K. APL remained true to its concepts of simplicity and practicality. Designers had freedom to make major changes because there was no machine application for the first seven years. [1] But the big difference is that APL was consistently controlled by a small group of people who remained primarily the same, and did not hand it off to other strangers, and were confident enough in their own creation that they received and implemented outside ideas. This openness to change and the designer freedom to make changes may play a key role in the fact that ALP is still an active language in some applications. SCALA featured “lazy evaluation”, and was a logical and efficient language, that evaluated by omitting processes not needed through “strict” or “non-strict” determination. SIMULA extended ALGOL by way of its processes (data carriers and agents of action execution), operating in active parallel phases, and ushers in object orientated characteristics as a good demonstration of communicating process description.

SIMULA is the basis for the subsequent lead in to Object- Orientated programming where programming aims are satisfied with objects. JAVA is synonymous with the concept of object- oriented programming, and currently one of the most widely used languages around. It is a very “clean” language, developed to be simple, secure, and reliable. It is familiar, so it can be learned and implemented easily, and object-oriented to utilize software development. SMALLTALK is completely object-orientated, and executes via a message passing methodology that enlists active objects to send and respond to messages. It works well with programs featuring music and animation, and is described as being an enjoyable, understandable language. C++ is an object -orientated language developed as an extension of C, and is noted for its efficiency with high level organization, and flexibility. It enjoys widespread use, and is spoken highly of for efficiency and abundance of resources.

Finally, the Education languages, PASCAL, BASIC and LEGO, emerged as the rapidly growing and evolving computing environment demanded teaching languages. PASCAL became one of the most widely used programming languages of its time in introductory programming classes, and true to an educator’s nature is happy to lay the groundwork for future programming languages to enjoy success. LEGO presents an innovative, hands on approach to teach programming and has successfully been applied to teach both basic and advanced programs. The user- friendly language and design of BASIC resulted in an elementary approach in a teaching language that the private citizen could use and understand, adding features as desired.

This journey through the evolution of programming languages is a tribute to the courage and fortitude of the computing pioneers who have made invaluable contributions to computing history, and visibly demonstrates how one advance led to exponential subsequent advances. Given this history, can we even imagine what lies ahead?

Evolution Of Computing December 17, 2017

Posted by kevinmea in Programming Languages.
add a comment

The evolution of computing practice as reflected by programming languages.

The evolution of programming language was not evident to me until I took this seminar.  Even after this seminar, this topic is so large that I feel we have only scratched the surface.  After spending a semester learning about the history it is clear that programming has come a long way from Alan Turing to the latest cutting edge data science tools.   I will look at three languages briefly to try to walk through some history of programming.

We started this semester looking at languages like Fortran.  Fortran is a general purpose, imperative programming language that is especially suited to numeric computation and scientific computing. [1]  This language was developed in the 1950’s by John Backus for mainframe computers.  The language included basic programs composed of blocks and made use of IF statements and other numeric calculations.  Fortran also provided support for procedural programming by introducing statements which allowed programmers to create subroutines and functions, thereby encouraging the re-use of code.  [2]  This allowed programs to grow in complexity and allowed programmers basic control of procedures and efficiency.

We looked at the C language next.  C is a general-purposeimperative computer programming language, supporting structured programminglexical variable scope and recursion [3]  Most people like to say that C is close to the machine.  In 1985 Windows 1.0 was released. Although Windows source code is not publicly available, it’s been stated that its kernel is mostly written in C, with some parts in assembly. Linux kernel development started in 1991, and it is also written in C. [4]  Those are two of the largest operating systems out there.  One for enterprise and one for open source.

Finally, I investigated the Python language.  Python is a widely used high-level programming language for general-purpose programming, created by Guido van Rossum and first released in 1991. An interpreted language, Python has a design philosophy that emphasizes code readability (notably using whitespace indentation to delimit code blocks rather than curly brackets or keywords), and a syntax that allows programmers to express concepts in fewer lines of code than might be used in languages such as C++ or Java.  [5] Python is used to program popular applications like Dropbox and Eventbrite.  Python is popular for concise code and is used extensively for data science purposes.  Since data science has overtaken analytics and is the growing trend, so is Python.  Data science is now a huge field covering everything from data collection, cleaning, standardization, analysis, visualization and reporting.   One of the most popular data science libraries is Pandas for Python.

References:

[1] https://en.wikipedia.org/wiki/Fortran#History

[2] https://www.obliquity.com/computer/fortran/history.html

[3] https://en.wikipedia.org/wiki/C_(programming_language)

[4] https://www.toptal.com/c/after-all-these-years-the-world-is-still-powered-by-c-programming

[5] https://en.wikipedia.org/wiki/Python_(programming_language)

[6] http://dataconomy.com/2016/10/big-data-python/

History of the Programming Language December 17, 2017

Posted by aaronzott in Programming Languages.
add a comment

A programming language is just like a foreign language to me; at first glance I have no clue what I’m reading, there seem to be an endless amount of the languages, and how do I decide which one to learn? Which one would work best for what I want to build? What do I even want to build? Well, today I’m a systems administrator so the language I must use is PowerShell because it is an integral part of nearly every product I work with. But, if I was to learn a language more commonly associated with programming, I would be looking at either Python or Java among the myriad choices of popular languages in existence today, including C++, Swift, Ruby, and others [1]. What if I didn’t have that multitude of options though? What if it was the 1950s, during the early age of programming languages, when you would instead roll your own language because you would be unlikely to find one that had all the traits you wanted or needed for whatever you wanted to do.

In those early ages of programming languages, many of the creators were building languages for a specific purpose and this resulted in a boom of languages and innovations, sometimes guiding the computer industry and providing concepts still used in languages today. FORTRAN, COBOL, LISP, and ALGOL were some of the languages developed for a specific purpose in the 1950s. FORTRAN was developed as a scientific language and excels at calculations. Mathematical programming, in a time when computers used punch cards for data processing, were taking up too much computer time. It was inefficient, and thus a language that could potentially save time was created. FORTRAN was one of the first languages to make programming and compiling fast, allowing companies to save computer time and therefore money. Those successes helped FORTAN become the first widely used programming language. COBOL was developed for a specific purpose as well – a group of people and organizations needed a language that could be used among a variety of businesses. This required a degree of machine independence and was one of the first language that could be ported to another kind computer architecture. It also had the pieces that would end up influencing database management systems like SQL [2], an example of a language from decades ago influencing products used today.

LISP was also a mathematical based language but was more hardware restricted than the others, so not portable. Yet, it excelled when used for AI research, so hardware was tailored to the language instead, leading to innovations in GUIs and the computer mouse [3].

One of the more influential languages of that time was ALGOL. Not only did it introduce code blocks and nested functions, it was the first that included an extremely detailed description of the language which was a major influence on future languages. The Backus-Naur Form was developed to describe ALGOL to specifically describe what is and isn’t allowed [4]. The BNF still lives today, the ALGOL language itself wasn’t as successful.

Another language from this period was BASIC. BAISC was created for education, but unlike the others, it was intended for non-programmers. The creators knew that other languages like FORTRAN and ALGOL were far too complicated for non-programming students to learn but understood that those students still needed to learn how to use computers. So BASIC was born. It was extremely simple and easy to learn. This led to widespread adoption and a proliferation of spinoffs because it was easily ported to the various home computers that were becoming popular, including Commodore 64, older Apple computers, and even the Atari [7].

Interestingly, as the years went on some organizations recognized a need for a general purpose and machine independent programming language. In the 60s and 70s this need produced languages like PL/I and C. PL/I was developed with the idea users would migrate from FORTRAN and COBOL to it because it would have the features of both, but it had limited success. C was far more successful, both due to the purpose of the language and its timing in relation to the evolving computer industry. As a language, it was designed to develop apps of all kinds, a true general-purpose language, and it was good it. More importantly, it was abstract from hardware – the compilers were excellent at adapting the code to numerous architectures. And at the same time, the Unix operating system was rewritten in C, allowing it to be extremely adaptable and portable, leading to the mass adoption of Unix and all the kinds of hardware that could easily run it.

Other languages were born in the 60s and 70s with various levels of success. Modula popularized the concept of programming modules, where a module of code could be repackaged into another program without changes, and modular programming can be found in modern languages. Yet the language excluded some interesting features, like exception handling and garbage collection. On the other hand, the ML language developed in the 70s did include garbage collection, but did not require users to define variable types. It was an interesting look at what some programmers considered important.

And then you get APL – if there is any one language that is most like a foreign language, APL would be it.  APL code uses a variety of symbols next to its numbers, and required a special typeball or keyboard to code [5]. The idea was that each symbol represented a mathematical function which would simplify programming. APL was, like FORTRAN or LISP, developed for a very specific purpose and while itself not widespread, it did influence the design of applications like MATLAB and Excel, apps intended to make mathematical manipulation easier but also without requiring a special typeball.

An extremely influential language born in the 60s was Simula, and it introduced the concept of objects in programming. It was designed for simulations, so the creators wanted to define a way to contain the definition of some idea and all its properties into a single object, and thus object-oriented programming was born [6]. Many modern languages like C++, Java, Python, Smalltalk, and Pascal are considered object oriented languages. Smalltalk was one of object oriented languages influenced by Simula and itself became popular in education and research and influenced both future object-oriented languages and the graphical user interface [7]. C++ and Java are now two of the most popular and widespread languages that adopted many features of previous languages like Smalltalk, and are general purpose in nature. Java was also created to be portable – the Java Runtime Environment can run on almost any time of computer or device, and Java code only requires the JRE, which essentially means that software written in Java can run anywhere.

The evolution of programming languages was interesting to dive into, even as a non-programmer. It was clear how the hardware of the 50s and 60s affected the development of languages, and how languages changed from purpose-built and hardware specific to general purpose and hardware agnostic once computers became less expensive and started to spread to homes instead of just universities and labs.

[1] http://www.businessinsider.com/the-9-most-popular-programming-languages-according-to-the-facebook-for-programmers-2017-10/#1-javascript-15

[2] Sammet, Jean E. 1981, p. 236-237. “Paper: The Early History of COBOL.”

[3] https://en.wikipedia.org/wiki/Lisp_machine

[4] http://www.garshol.priv.no/download/text/bnf.html

[5] https://en.wikipedia.org/wiki/APL_(programming_language)

[6] https://www.whoishostingthis.com/resources/simula-programming/

[7] https://arstechnica.com/features/2005/05/gui/3/

[8] https://en.wikipedia.org/wiki/BASIC

The development of programming language December 13, 2017

Posted by yuboli in Programming Languages.
add a comment

I think the development of computer programming language is roughly divided into 3 stages:

1-Mumbo-jumbo – machine language

The original computer uses a binary number composed of “0” and “1”, which is the basis of the language of the computer. At the beginning of computer invention, computers can only be used by a few people. People need to use 0 or 1 instruction sequences to be executed by computers. It is a headache for machine language to use and popularize. There is little ability to transplant programs, so the cost of time and human cost are very expensive.

2-Assembly language

Because it is difficult to understand the machine language, people began to think of the use of mnemonics instead of 0,1. So the assembly language appeared. It uses some simple English letters and string to replace a specific instruction binary string, which also improves the memory and recognition of language. It has played a positive role in the development and maintenance of the program. Assembly language also operates directly on hardware, which still limits its portability. But assembly language program compiled by assembler language for computer specific hardware has made great progress in the function and specialty of computer hardware. It is refined and high quality, so it is still a commonly used programming language nowadays.

3-High-level language

In the continuous communication with computers, people’s demand for computer programs is increasing. At this time, a language that does not depend on a specific type of computer is urgently needed. Programs written in this language can run normally on various platforms. Since the birth of the original language, hundreds of languages have emerged. The development of advanced languages has also developed from the original structured language to process oriented language design and object oriented language design.

The following focuses on the development of advanced languages.

Fortran is derived from the abbreviation of “formula translation” (. It is a programming language. It is the earliest computer advanced programming language in the world, which is widely used in the field of science and engineering computing. The FORTRAN language plays an important role in the field of numerical, scientific and Engineering Computing with its unique functions. In 1954, John Bekkers in New York officially released, called FORTRAN I. FORTRAN I function is simple, but its pioneering work, caused great repercussions in society.

LISP name from the list processing (List Processing) of the English abbreviation, a pioneer in artificial intelligence research from the Massachusetts Institute of Technology John Macarthy (John McCarthy) in 1958 based on the lambda calculus created by abstract data list and recursive symbolic calculus derived for artificial intelligence. It is mainly used in the field of artificial intelligence.

ALGOL is the abbreviation of the ALGOrithmic Language, which is the first of the first clearly defined high-level languages in the history of computer development. The International Computer Society (ACM) lists the ALGOL model as the standard of algorithmic description, which inspires the emergence of the modern language of the class ALGOL, Pascal, Ada, and C.

COBOL (Common Business Oriented Language) is the first widely used high-level programming language. In enterprise management, numerical calculation is not complex, but the amount of data processing information is very large. In order to solve the problem of enterprise management, in May 1959, The Pentagon commissioned Grace Hobo (G.Hopper) to lead a committee and was presided over by Rear Admiral Grace Hopper company. It was released by the American Association for data system language in 1961. Through constant modification, rich perfection and standardization, many versions have been developed.

APL is A Programming Language or Array Processing Language abbreviation. When he was designing the language in 1962, Kenneth Everson was working at Harvard University. In 1979, he got Turing Award for his contribution to mathematical expression and programming language theory. It is a computer language that interpretations and executes.

Simula 67 is considered as the earliest object-oriented programming language. It introduces all the basic concepts followed by object oriented programming language: object, class and inheritance. After that, the formal text of Simula 67 was formed in February 1968.

The PL/1 language is one of the most popular structural programming languages in the world.

Smalltalk is recognized as the second history of object-oriented programming language and the first truly integrated development environment (IDE). Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg are developed at Xerox PARC in the early 70s. Smalltalk has played a great role in the creation of many other programming languages, including Objective-C, Actor, Java, and Ruby. Many software development ideas in 90s were beneficial to Smalltalk, such as Design Patterns, Extreme Programming (XP), and Refactoring.

C language is a universal computer programming language, which is widely used. The design goal of C language is to provide a programming language that can compile, process low-level memory, generate a small number of machine codes and run without any operating environment support in a simple way. It’s a long time.

C++ is the inheritance of C language. It can not only carry out C language’s procedural programming, but also carry out object oriented programming based on abstract data type, and also carry out object-oriented programming with characteristics of inheritance and polymorphism. C++ is good at object oriented programming and can also be a process based program set.

Java is an object oriented programming language. It not only absorbs the advantages of C++ language, but also abandons the concepts of inheritance, pointers and so on, which is difficult to understand in C++, so Java language has two characteristics: powerful function and simple and easy to use. As a representative of static object oriented programming language, Java language implements object-oriented theory excellently, allowing programmers to do complex programming in an elegant way of thinking. Scala is a multi – paradigm programming language, a programming language similar to Java.

The development of computer programming language is mainly divided into two categories. One is a structure oriented programming language, such as PL/1, C. One is an object oriented programming language, such as Simula 6, Java. They each have their own characteristics, their own wonderful.

 

References:

[1] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2171690/View

[2] https://en.wikipedia.org/wiki/Simula

[3] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2176442/View

[4] https://en.wikipedia.org/wiki/PL/I

[5] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2181351/View

[6] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2182006/View

Evolution of Programming Languages December 12, 2017

Posted by Dawn Turzinski in Programming Languages.
add a comment

Have you ever sat back in your chair and wondered how people got through their day without computers? I think back to when my parents were born in the 40’s and I can’t even imagine.  How did people know how much money they had?  How did one shop know; how much sales they did that day/week/month/year?  How about inventory?  All this was had to be done by hand and on some sort of paper.  Or they paid someone a lot of money to sit there and tabulate that all for them.  Over the course of this semester we read about different programming languages.  And we saw the evolution of programming happen right before our eyes.

Here is a list of programming languages we studied this semester:

FORTRAN, COBOL, LISP, ALGOL, C, PL/1, MODULA, ML, APL, SCALA, SIMULA, C++, SMALLTALK and JAVA

As we read about each one of the languages listed above; we learned that each one was written for a purpose in mind.  The first language we looked at was: FORTRAN which designed by John Bachus and his researchers at IBM for Scientific and numeric computation.  While the community was not convinced that this method would outpace hand coding by a factor of 20. It slowly gained acceptance. [2]

The next language was COBOL; where a group of businesses gathered together to build a common business orientated language.  It was built purely for business cases in mind. Where no academia was involved and it became a widely used legacy programming language still in use today.  It created the notion of a database management system.  Where, we have the Data Division which was split into six sections that declare your items.  “You have the File Section for the file records; the Working – Storage Section for your static variables; the Local-Storage Section for automatic variables; the Linkage Section for parameters and the return value; the Report Section and the Screen Section for text-based user interfaces”. [3]

LISP the next language we looked at; which is the second oldest programming language.  And was created as an everyday mathematical notation for computer programs.  It was the favorite among programmers for research in Artificial Intelligence.  But as we saw in previous seminars there was an AI Winter where there was no movement until the 80’s.  With the emergence of the arcade came some new interest in AI again.  Today the best-known dialects of LISP are Common Lisp and Scheme.  [5]

The forth language ALGOL was designed by computer scientists in USA and in Europe. It was not used commercially because it lacked Input/output features needed. However, this language had an influence on future programming languages.  That influence was the Backus-Naur form.  Which is a principle formal grammar notion for designing programs.  Some of the concepts we are so familiar with today such as if then else, for, the := symbols, Switch statement, begin, end and the while loop came from ALGOL.  [8]   Many of the programming languages we use today are ALGOLA like.

The next language we looked at was C.   It is a General-purpose structure programming language with a static memory system, recursion, lexical variable scope.   C has been around awhile and doesn’t seem to be going anywhere anytime soon. [9] C was designed for the UNIX operating system, which is still in use today.  The language is very portable which remains translatable with small compliers. Its Central Library was never designed in isolation.   This language has paved the way for C++, C#, Pascal, JavaScript, Perl and others.  [10] C is in our lives everywhere; In fact, a lot of projects that were started years and years ago are still in existence today.  According to an article I read you don’t even realize how woven the C language is in our daily lives. Microsoft Operating system kernel is mostly C; Linux is mostly written in C.  Surprising to me but Mac’s OS kernel is written in C.  Many of the mobile platforms are also written in C.  Also, all the popular databases are written in C (Oracle, MySQL, MS SQL Server and PostgreSQL).  3D movies and Embedded Systems (Many of the systems in your car). [11]

The sixth language PL/1; which was the result of FORTRAN and COBOL people coming together to produce a combination language.  As you look at PL/1 programs it contains syntax that is both COBOL and FORTRAN alike.  This language was not very portable and had a hard time getting off the ground because programmers disliked one of the two.  PL/1 has no reserved words, block structures and exception handling.  I can’t imagine not having reserved words.  How, can you code an;(IF, Then, Else) statement or even Date reserved as a word.   However, PL/1 was the first language for Exception Handling.  If you try to divide by zero, the program would abort.  On-units allow the program to stay in control and allow the system to recover the debugging information before gracefully closing the program. [14]

MODULA the next language; which was only used in University setting.  It was very well thought out and planned of what was going to be included and excluded.  Items were coded and executed to the level of perfection.   The language was viewed as very powerful and word of mouth spread on how sound the product was.   Its language fingerprint was small but was a favorite among small clients.  [6].  This language made me think about how sometimes we like the smaller fingerprint product versus commercial buggy products.

The next language ML; which is a standard Meta Language that is modular, functional, strongly typed and compile time type checking. [8] when I think of some of the software that is being built today, I think of modular.    Why program a whole product when you can piece together what you need?  And modify only the pieces that need fixing; while giving the customer a feature enhancement faster. We are striving today to bring software applications to the client base faster in a modular way.

The ninth language APL; which is a mathematical language that utilizes its own developed character set on arrays.  [15] Even though APL is on the decline, it is still being used in Machine Learning, Robots and even in Accounting.  [16] I didn’t even realize that APL was used for graphics in the movie, “TRON”.  And was used for the Lottery Quick Pick 6.  If you need a simple, repetitive mathematical equation APL is the language to use.

SCALA the next language is an all-purpose functional programming language that has a strong static type system. This language was designed because of what Java fails to address.  [17] Have you ever tried to read Java code and found it not very reader friendly.  SCALA does just that.  There are syntax differences with SCALA and they are:  Semicolons are not required to end statements, Types of values are in upper case: INT, Double, Boolean, Parameter and returns follow Pascal, Methods have a def in front of them. [1]

The next language SIMULA; one of the first object orientated languages designed for simulations.  This language provided the framework for many of the features of object orientated languages today.  Those features include: objects, classes/sub classes, inheritance, virtual procedures, coroutines and forms of subtyping.  SIMULA is a subcategory of ALGOL.  [19]

The twelfth language we looked at was C++ which was designed to provide SIMULA’S features for program organization with C’s efficiency and flexibility. [20] C++ contains features of objects, encapsulation, inheritance, operator overloading, polymorphism, virtual memory functions and exception handling. [21] C++ just expanded the use of object orientated to allow you to program real life situations.  Programming in C++ gave you flexibility to write code in your own style but you are responsible to follow certain guidelines to not fall into bad pitfalls.

JAVA is the next language we looked at that was designed to lessen implementation dependencies.  It relies on a Java virtual machine that is very secure and portable. The language is statically typed with syntax that is like C++ but not compatible with it.  Allows for an interface to call C++ programs, automatic garbage collection, objects, no operator overloading and single inheritance [22] Since it is portable the whole notion of run once you can load it anywhere.

The last language we looked at was SMALLTALK.  I found it to be very English reading friendly but was built to be an educational resource.   After reading the Wiki about Smalltalk, it took second place for the “most loved programming language” in the Stack Overflow Developer Survey in 2017. [23] I researched this a little more deeper and realized since it is very reader friendly; some people say that learning Smalltalk first was beneficial.  This will lay the ground work for one to understand the object orientated concepts.  Then learn all the other object orientated languages. [24]

All of languages we looked at this semester are building blocks for future languages.  You never know what new language is on the horizon.  Since we know that each language had its own purpose and reason to be developed.  What is the next new trend, new idea.  We will soon find out.

There are other programming languages that are interesting, but are not mentioned in my blog and they are: First language (ada Lovelace), Assembly, Autocode, Flow-Matic, IPL, UNCOL, IAL, APL, BASIC, ISWIM, Attribute grammars, LOGO, SNOBOL-4, CPL, BCPL, PASCAL, Forth, Prolog, SQL, Awk, Scheme, CLU, Plasma, Sasl, Icon, Ada, Eiffel, GAP, Miranda, Caml, Perl, Oberon, Haskell, ABC, Python, Pov-Ray, DisCO, Ruby, PHP, JavaScript, UML, ECMAScript, Rebol, C#, R, AspectJ, Scriptol, Go, Julia, Dart, Rust, Asm.js and Swift. [18]

References:

  1. Jan Lee, John Bachus, George Ryckman, The History of FORTRAN I, II, and III, page 26 in History of Programming Languages, Association for Computing Machinery Inc., 1981.
  2. https://en.wikipedia.org/wiki/Fortran
  3. https://en.wikipedia.org/wiki/COBOL
  4. Sammet, Jean E. 1981. “Paper: The Early History of COBOL.” History of Programming Languages(Academic Press, Inc.
  5. https://en.wikipedia.org/wiki/Lisp_(programming_language)
  6. Wirth, Niklaus. Modula-2 and Oberon.”
  7. https://en.wikipedia.org/wiki/Standard_ML
  8. https://en.wikipedia.org/wiki/ALGOL
  9. https://en.wikipedia.org/wiki/C_(programming_language)
  10. Dennis Richie – Development of the C language
  11. https://www.toptal.com/c/after-all-these-years-the-world-is-still-powered-by-c-programming
  12. https://en.wikipedia.org/wiki/PL/I
  13. Sibley, PL/1 – PDF Handout
  14. https://en.wikipedia.org/wiki/PL/I
  15. https://en.wikipedia.org/wiki/APL_(programming_language)
  16. p47-iversion(APL).pdf
  17. https://en.wikipedia.org/wiki/Scala_(programming_language)
  18. http://www.scriptol.com/programming/history.php
  19. https://en.wikipedia.org/wiki/Simula
  20. B, Stroustrup. The History of C++: 1979-1991.
  21. https://en.wikipedia.org/wiki/C%2B%2B
  22. https://en.wikipedia.org/wiki/Comparison_of_Java_and_C%2B%2B
  23. https://en.wikipedia.org/wiki/Smalltalk
  24. https://stackoverflow.com/questions/1821266/what-is-so-special-about-smalltalk

Programming Language History December 11, 2017

Posted by duoalex in Programming Languages.
add a comment

              Generally, programming is the process to allow the computer to solve some sort of problems with the code that computer can understand. According to my understanding, programming language is the medium between people and the computer. When the computer was initially released, the cost of each computer hardware was very expensive whereas the cost for software development was significantly lower. As a result, most tech savvy individuals paid more attention into the development of computer hardware and its processing power. However, as computer hardware advances, the processing power of each individual unit increased significantly which directly results in the capability of solving computational algorithms that is of higher complexity. Besides, the improvements in its processing power and capabilities, the cost for computer hardware were gradually decreasing as well. This introduced a new challenge that the time and cost needed to invest into software development has become significantly greater than the cost of purchasing computer resources. Considering the newly introduced challenges and the revolutionized improvements for computational power, we ought to iterate and upgrade the version of programming languages to adapt to the changes in the overall environment and to fulfill the requirements set forth in the industry.

        In 1950, the computing industry faced a challenging crisis, the programming modules were not capable of satisfying the need of the high resource usage software. That crisis indirectly created several programming language such as c++, java and eiffel which were capable of supporting those high resource usage software. These languages each took a different perspective to view the existing problems at that time. They view the challenges and problems as the process where variables of different types interchange information and resources. In addition, these languages has a strong adaptation abilities such that most of the issues can be resolved using software developed by these three languages. Besides, these languages were significantly different than the software programming languages that were used at that time such as c, pascal and fortran.

               The programming languages that are the most common nowadays consists of two types, assembly languages and high-level languages. Assembly language and machines languages were essentially the same as they were both used to directly command the hardware components. High-level languages were preferred by the majority of the software developers, because not only did it combined relevant commands into one single line command, it also removed minor commands that were not necessarily valuable such as the usage of stacks and registers to store values. Considering that high-level languages are simplified, this ensured that the software developers who wished to enter into the software industry do not need to possess much of technical skills and knowledges and are able to learn as they go.

             As the requirements for software scope and the complexity of software algorithms increase and expand, more and more programming languages will be designed and created. Languages such as Python, Ruby, R and PHP would serve as the by-product of these mainstream languages which has their own type of advantages and specialized usages.

By: Duo Zhang

References:

[1] Urma, R. G. (2017). Programming language evolution (No. UCAM-CL-TR-902). University of Cambridge, Computer Laboratory.

[2] Kernighan, B. W., & Ritchie, D. M. (2006). The C programming language.

[3] https://en.wikipedia.org/wiki/Programming_language

[4] Krishnamurthi, Shriram. Programming languages: Application and interpretation. Shriram Krishnamurthi, 2007.

Programming Languages – Mathelier December 10, 2017

Posted by 1969mathelc in Programming Languages.
add a comment

The way that programming languages is viewed today is much different from how it was in its early days. From the design of the languages to how the languages are learned, much has changed although the goal to provide faster, easier and powerful computing capabilities has remained the same. One of the major advantages in today’s programming world versus the past is the lack of hardware limitations that the designers of the past had to deal with. With the advances in hardware, proven by Moore’s Law accuracy over the past few decades, software development is no longer as heavily dependent of hardware. In the past, the software’s dependency on the hardware was so dominant that many of the software was developed specifically for certain hardware. Nevertheless, many of these older languages have thrived over the years and have influenced many others to be created.

Even in the early years of programming (1950s), there wasn’t only just one language in existence. Nevertheless, a few of the popular ones were FORTRAN, COBOL and LISP. Each one of them had their own purpose and separate audience. FORTRAN and other automated programming from the past provided solutions to hardware limitations that existed at the time; furthermore, the price of programmers at the time were as expensive as the expensive computers that they worked on [1]. As FORTRAN succeeded in the performance level that they had promised, it is evident that much of the manual labor that was being executed at the time would be automated. COBOL, on the other hand, was created out of the necessity to have a common language for business-oriented individuals. The success of this language was measured by its simplicity. The simplicity entailed for the language being more readable than the ability of learning it by non-programmers. LISP is known to be the second oldest programming language [2], and even in modern days it is still relevant. LISP was one of the first contributors of the development of Artificial Intelligence (AI) [2]. It can be safe to say that Artificial Intelligence from that era is very much different from our perception of Artificial Intelligence today. Because of the previous limitations, programmers involved in the development of LISP, COBOL and FORTRAN needed to have a thorough understanding of these hardware limitations and design around that. Although that task must have been very much challenging, their knowledge in assembly language surely must have benefited them. It made much more sense back then for hardware to be designed for the efficiency of a specific language, whereas in modern time, hardware architecture is designed for general purpose.

As hardware capabilities were increasing over the years, general purpose programming languages started to become popular.  In the 60s and early 70s, languages such as ALGOL, C and PL/1 were very influential.  ALGOL was designed by some of the top computer scientists at the time. They were very serious about laying out a solid foundation on a language that would be served as general purpose rather than for specific purposes. Most languages that we know today are general purpose, and it is more than likely that they use a feature of ALGOL. From code blocks, to the use of dynamic arrays, ALGOL had many firsts to offer to the programming world and also influenced the other soon-to-be popular languages. One such language is Pascal which is considered to be very efficient and intended to encourage good programming practices; many institutions use Pascal as their introductory programming language. C is obviously one of the very popular languages and it has been stable for quite some time now. The success of C can largely be credited to the success of Unix which was eventually programmed in C [4]; this allowed for many developers to be exposed to the language. The language’s portability also played a major role in its success, although portability was not initially the designers primary goals. Throughout the years, the language has gone through a few revisions, but has become a standard language which thrives even today. PL/1 was developed by a group which included members of IBM and of FORTRAN. The language was meant to be very customized as IBM was developing new hardware, and it needed code that would interact effectively with its hardware. Many programming functionalities that we heavily rely on today such as memory allocation, multitasking and recursion were already dominant at the time of PL/1. The language influenced many subsequent languages directly or indirectly.

Throughout the years, not all programming languages that were developed were extensively used in the corporate world. Many were developed for research purposes and were not necessarily commercialized. A few that were discussed throughout the seminar were MODULA, ML, APL, SCALA and SIMULA. Although not as popular as some of the languages previously mentioned, these languages certainly had considerable influence on other languages. The one that I find the most interesting is APL’s influence on Matlab. APL used special graphic symbols to represent mathematical symbols in a much more efficient way. The usefulness of these mathematical symbols become apparent when trying to code complex mathematical functions. A language such as MATLAB makes a dramatic difference for that purpose.

Object oriented programming adds a new twist compared to the traditional functional programming. The concept of object oriented revolves around the creation of objects to represent a unique entity. These entities can be modified or requested information from through the use of function calls. A few popular object-oriented languages are Smalltalk, Java and C++. The latter two are very popular in today’s programming world. C++ is the object-oriented language that tries to merge the world of object oriented programming while retaining the control offered by C. C++ is now a standardized language that influences many other object oriented languages. Its unique treat is its capability to give users low level access. Java was designed specifically to remove much of the burden from the programmer. The most obvious of these burdens is memory allocation which can be very confusing and can be the source of many errors. With the use of java virtual machine, programmers do not have to worry much about which platform that they’re working in and can focus more on functionality of their code. Java boasts itself to be portable, robust, secure and simple [5]. Java was my first programming language learned though school, nevertheless languages such as Pascal, Lego and BASIC are popular for educational purposes.

 

REFERENCES

[1] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2171690/View

[2] https://en.wikipedia.org/wiki/Lisp_(programming_language)

[3] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2181351/View

[4] https://d2l.mu.edu/d2l/le/content/328978/viewContent/2182008/View

[5] http://www.oracle.com/technetwork/java/intro-141325.html#334

 

Programming Languages December 9, 2017

Posted by chadkohler in Programming Languages.
add a comment

Throughout the class I’ve learned that the creation of programming languages has occurred many different ways. There were times when larger, inter company committees were formed, a handful of people did so behind closed doors, or even through government and educational institutions. The different application and purpose of these programming languages vastly impacted the type of team that was put together to form it. The impact on the different aspects of these development teams that created Basic, Lego and Pascal will be explored.

Basic and Lego were both created for educational purposes and the common ground among themselves was also shared in their development teams. They were created in small teams that each prioritized ease of use and intuitiveness over efficiency or speed. The programs were developed to be used with simple hardware and relied on ease of use to promote growth. Also, practice runs with their target audience was a tool they used to ensure they had built a good product. For Basic, the first iteration was tested on with Dartmouth students, while for LEGO it was with K-12 students. The different institutions realized that it was more important to have agile teams that could quickly respond to customer needs, than have a larger team develop really specific code.

Pascal was developed to introduce a new, more efficient programming practice currently referred to as object-oriented programming. A member of the international federation of information processing group created pascal. In this instance, access to a larger team to create more custom programming language solutions was beneficial. The highest priority of this language was to develop a tool to more efficiently create software, not introduce a better user experience. Additionally, the nature of this application leads to much more detailed iterative versions, something not seen with Basic and Lego.

In general, there are many different features considered when teams are put together to create educational and higher performing programming languages. There are common differences between these teams due to their applications. Educationally based programming languages were developed in a modular fashion, incorporating a small number of people to make simple, user friendly iterations. While the efficiency based programming languages were done in larger groups to make advanced, custom development decisions.

A Change in Perceptions December 6, 2017

Posted by logfritz in Programming Languages.
add a comment

Wow! What a ride this journey through programming languages has been.  I started off my career in Computer Science with no idea what I was getting myself into, nor the history involved with it.  And I can prove it too.  My background was in aircraft structures, and generally I was happy when my computer booted up properly and my ‘software tools’ didn’t error out on me.  I’d spent a few semesters in my undergraduate learning Matlab and a bit of Java, but I did so for the utility of the tool, not to gain an understanding of computing.

When I entered industry, I was immediately expected to learn C++ and Java and get a grounding in HTML and CSS for front end user experience.  I did so, again for the end goal of using the languages, and would constantly run into issues.  I wouldn’t understand why C and C++ used pointers, or why I should care about memory addresses.  I didn’t understand the big difference between having 32-bit integers versus 64-bit other than I could use bigger numbers.  I also didn’t understand it when my colleague’s with more experience kept telling me how easy I had it.  Pretty much I didn’t understand why the languages I was using had limitations, or the challenges that were overcome to get to today.

This experience, along with some experiences in my career, changed my perceptions.  Reading through the early whitepapers that defined languages like COBOL and ALGOL and FORTRAN made me realize that in the past, the languages had to specifically conform to a specific piece of hardware within a machine.  And to think that I used to get angry when configuring my Eclipse environment to work with existing projects.  And even languages that I consider modern, like C, still have to work around machine dependence and other low-level issues, such as what typeset they will accept.  I will never forget that APL utilized an 88-character Selectric typeball.  And that some characters within the language can be created by typing characters on top of each other.

It amazes me how far the computer science community has progressed in the last 6 decades.  And it gives me awareness.  As I continue my career, I will remember that it is not only to the future of the industry that I need to look.  By taking the time to look to the past, I’ve gained a better understanding of the present, and an expectation for better things to come in the future.

Evolution of Programming Languages December 5, 2017

Posted by Anthony Mason in Programming Languages.
add a comment

I really enjoyed learning about the development of programming languages over the past 40 years in the Programming Languages seminar. In the class, we started by taking a look at early programming languages such as FORTRAN, Cobol, and Lisp that sparked the software development landscape that we know today. It was cool to see how these languages were created from committees of people with various backgrounds and agendas that came together for the better good of society as a whole. During this time in programming languages, the development of programming languages was very tied to the development of the hardware and was significantly limited by the available memory and computational power of the host system, with the exception of COBOL that was designed to be portable and independent of a specific system.

Next, we transitioned to general purpose programming languages like Algol, C, and PL/1. Out of all these languages, I would have to say C was the most popular and impactful procedural programming language of the bunch as it is still heavily used today due to its syntax and the level of control it can provide to the programmer.

In the third segment of the class, we shifted our focus to programming languages that were developed for specific research domains. The languages we explored included Modula, ML, APL, Scala, and Simula. We examined Wirth’s thought process in making Modula 1 and Modula 2 and analyzed some of the critical features he opted to leave out of the language such automatic garbage collection and interrupts which have become staples of modern programming languages. ML was my favorite out of this section due to the formal semantics of the language which I found to be very similar to Python in a lot of ways, especially the type inferencing. APL was designed to help the linear algebra and tensor analysis space while we looked at the effect of lazy evaluation offered by Scala and Simula’s coroutine feature.

Lastly, we concluded by examining object-oriented languages such as SmallTalk, C++, and Java. Java is the one language that I have personally used the most next to C. It was cool to see how C++ and Java adopted a lot of features that were first present in SmallTalk, a language I never explored before this class. After learning about the differences between these three languages I am more appreciative of everything Java brings to the table.

In conclusion, I enjoyed learning the trends of programming languages that occurred over the past four to five decades and will look to continue to research the history of programming languages outside of this course to be a more well-informed software developer.

The evolution of computing languages December 5, 2017

Posted by omarabed15 in Programming Languages.
add a comment

It’s amazing to think about how programming issues and focuses change over time. Back when FORTRAN was commonly used, most debugging time was spent resolving floating-point issues. This is now handled automatically by most languages. FORTRAN was also expected to “eliminate the need for programming and debugging”, but we see how successfully that goal was met…

Jump ahead to COBOL, and we see programming being used in a more practical application, with specific focus on business applications rather than just computationally-intensive problem solving. It seems that the many uses of programming languages were realized early-on, and people tried to take advantage of the potential benefits. However, when we consider LISP with COBOL and FORTRAN there is an important point to realize. Each of these languages was developed for a specific computer and specific processor in mind. For that reason, I think any nuances of the languages (and how they affected future languages) may have begun from a less-than-ideal solution to a specific processor issue. It’s interesting to think of the tightly coupled software-hardware world that programming begin as, and how far it has come to a highly portable practice to write software in various languages.

I think C and PL/1 start to show a major shift towards portability and scalability. PL/1, with its lack of reserved keywords, seems to try to stay modular for all programmers to use it in various capacities. And C, with its adjustments to the use of arrays and types, resolved some of the issues previously seen with arrays in other languages. Solving these problems are general necessities for a language to persist and be modular for different applications. ALGOL can also be considered in this way, since it focused on implementing general-purpose algorithms successfully. Between ALGOL and C, I think we start to see a shift in the way programming was thought about. Rather than developing solutions for a specific processor or application, these languages attempted to solve universal problems and make programming more robust for different applications.

It’s interesting to think about how the landscape of languages goes in cycles. For example, languages started to become more general and robust, but then more specialized applications were desired and languages were created that specialized in meeting those requirements, such as APL meeting math needs. Languages went from tightly-coupled with hardware, to general and robust, and from there, specialized uses called for specialized languages.

From there, languages started to implement things slightly differently from each other, though they all consist of the same core functionality. Now programmers can choose the right language for their needs based on these little nuances. For example, C++ allows low-level garbage and memory management, and if that’s something you require for your application, then this is a great option to select. However, Java handles this automatically and if those are features you don’t require, Java might be the best choice.

Ultimately, I believe programming languages went through an interesting cycle of being tightly-coupled to hardware, then had more robust and general functionality, and then once those languages and features were fleshed out, more specific languages and features were created for specific needs. This cycle is quite interesting, and invites the question: How will future computing needs cause programming languages to change in going forward?

History of Programming Languages October 2, 2017

Posted by Marquette MS Computing in Programming Languages.
1 comment so far

Programming languages are a research topic for computer scientists, but they are tools for the developer. Programming languages provides a perspective on the state of computing when the language was designed. The profession of being a programmer or software engineer developed in the context of offerings from hardware and software companies and the evolutionary use of computing in business. The requirements of the programming languages needed to evolve to meet the needs of the programmers. The forefront of computing keeps expanding. In this evolution, batch processing was augmented by transaction processing which was further transfigured by e-commerce. The individual programming task was distributed to project teams, which led to crowd sourcing and open source communities. Single purpose systems were replaced by department computers and then personal computers were added, the computer became the network, and now ubiquitous computing is moving forward. As all of these changes unfolded, computer programming and system development changed. These papers by students will reflect on the past and look toward the future by considering the world of programming languages.