There seems to be this idea going around the internet that the reason someone isn’t able to program, is because languages aren’t good enough yet. A couple of people I have seen with have gone so far as to insinuate that the reason programming is to hard for most people, is because we design our languages to be too hard, just to keep people away from programming, and to secure our jobs. In reality, programmers are not trying to make their jobs harder, they are constantly trying to make their jobs easier. The truth of the matter is, programming is just hard.
Some people argue our current languages are too cryptic, other people argue that we need to abandon text-based languages all together, and just use GUI languages. What people don’t realize, is if GUI languages were actually easier, everyone would understand electrical engineering. Most people don’t understand electrical engineering, not because they don’t understand how to connect wires, but because they don’t understand the logic, math, and general engineering behind it.
As for the argument that programming languages are too cryptic, this is just a misunderstanding of what people really want. What people really want, is magic. So is an easy programming language impossible? No. Programming languages have plenty of room to get easier, and to evolve, however the act of programming itself, will never truly be easy, unless you are doing the most basic of tasks.
So just for amusement, what would the easiest programming language look like? Lets say we want to create a window with a table view that adds entries when someone clicks a button. What people would like, is to have a language that would understand some message such as
“Create a window with a table view, and then when someone clicks a button, add an entry to the table view”
While in theory its fully possible to parse a fully human-language, and then generate intermediate code based off of that, in reality, we don’t have that type of technology quite yet, as well as there isn’t near enough information given. What style of window? Initial position? Color? What about the table view? What type of data are the entries storing? How does the user interact directly with the table-view? What about menu items?
Also, what happens if we create two windows? How do we address first one, then address the second one? Well, we have to have some sort of variable naming convention, such as “Create a window named window1” wait, that’s going to be a challenge for the parser to interpret, are we naming the window window1, or are we setting a variable called window1? Lets redefine our variable definition syntax. “Create a window with title ‘Window 1’ and variable name wnd1”. Rather wordy, and already this language is getting complex.
What if we need to do something complex on an engineering level, such as create a scheduler? We can’t just go “Create a scheduler”, we have to figure out how its going to tie in the system, and fully understand the outcome of the code we write, as well as the internal code. So we’d have to describe every variable creation, and every action, to extreme details. It’d be easier to do it in a standard programming language, quite arguably.
All of this is not to say trying to advance programming languages is a bad idea, I’m just trying to explain, no matter how easy the programming language is, if you don’t understand the logic behind the code, you won’t be able to write it in any language.
The Lower Level 
You helped me understand a little more of the difficulty of programming. I think HyperCard was the easiest programming, but even there your points are valid.
Damn Straight and Well Put. Until you write code, you’ll never understand the power of it. I often talk to people who work with this or that GUI and think it’s the whole picture; but control isn’t just performing one task- it’s controlling every aspect of the task. I am always frustrated if I try to troubleshoot bugs in a GUI: how do you shoot what you can’t see? I think programming languages are getting better, but part of that is our evolution toward the machines. Fluent code isn’t anthropocentric; it’s transcendent.
There is an error in your second sentence. Also, you need to be more careful about punctuation. The comma is being misused, and overused in some cases.
He’s a programmer you’re lucky he didn’t use a semi-colon instead of a comma.
Buddy proof reads, his, article! for, @ punctuation… please
Jajajaja
I think that is a good example of why we don’t have any good natural language programming systems! Oxford comma debate anyone?
Who gives a fuck about an Oxford comma?
And isn’t it wonderful that humans are much better at parsing meaning from “incorrect” syntax than computers. 🙂 Imagine if we weren’t.
Therein lies the problem, I think. Some people think that because they can understand a set of vague commands that computers should be able to as well.
Very insightful. I agree programming languages are not that simple yet.
What your commentary alludes to as well is the necessity of requirements gathering. If we didn’t care what kind of window or what kind of scheduler we wanted to create, it would be unimportant to specify. However, we do care. We care because of the long legacy of design patterns that programmers before us followed, and we care because users have expectations of productivity and usefulness. In other words, as Ele pointed out: we need to control (and define) every aspect of the task.
Architects transfer requirements into a plan and developers execute that plan. The architects are taking the place of the NLP program you mention, clarifying the gaps and errors with BA’s and stakeholders, and building structure which the developers then fill in with the building blocks of that structure – the code itself.
Just as programming may never be “easy”, requirements gathering will always be tough as hell.
Just goes to show that humans still have minds that are useful, we’re still the lords over machines. Just imagine the future of mankind being spoon-fed by machines with whatever it is that our whims want… how dull would we be not being able to think and do stuff on our own. I used to be scared of programming till a lightbulb in my skull switched on. Your last sentence made its mark perfectly. People should know their logic first.
Pingback: Programming will never be “easy” « Yusufarslan.net
Programming languages are already very easy, just about as easy as you could wish them to be. What people complain about is that they lack the analytical ability to translate the end goal into the series of detailed discrete steps necessary to reproduce it. What they need is not an easier programming language, but a robot servant that solves the problem for them.
“[people] lack the analytical ability to translate the end goal into the series of detailed discrete steps necessary to reproduce it.”
Bingo. I teach programming. Many students are just not equipped to break down problems into precise discrete steps.
That’s right!
I don’t think that programming languages are difficult (I don’t even thing that programming itself difficult).
As usual, people lacks discipline and will to understand the basics and go to advanced stuff.
Everybody could be a programmer, just as they really want to,
That said, it would be far better if application development could concern itself with presentation and business logic, and push everything else into the framework. Application development then would be much faster and the applications more reliable.
Application developers then would concern themselves more with application analysis, and framework developers with the more technical issues, like scalability, reliability, recovery, versioning, etc.
Another factor we should consider is that we are using the worng machines for the job: Computers are machines that are at heart calculators. We made them run Windows, facebook and videos. Why do we do this with a calculator? We have to bend mathematics (and the abstracting languages) quite hard to get there and that’s where the problem might be.
Not really. Computers are calculators, but they are a lot more- calculators don’t really have anything to do with control flow or decision-making. When you’re using a calculator /you/ make all the decisions. Computers also have a lot of infrastructure dealing with input and output through tons of media.
What machine would /you/ use to run Windows, Facebook and multimedia? Think about it for a minute and you’ll probably come up with something really familiar.
Control flow is just the calculation of an address.
Well said!
Good essay, and glad to hear someone articulate this well. Programming is about good design of complex artifacts which has never been “easy” and will never be! Some things do become very easy, or automated, but then we move the goalposts, no longer call that programming, and attack new applications that were previously infeasible and now merely “hard”.
Great post! Loved reading it! It was insightful!
Programming is already easy- at least for easy tasks. The real problem is just that programmers have succeeded well at hiding complexity from users, so they don’t think about all the little things involved in converting thought to something computers understand.
And the example above is much simpler with some parser-level defaults. But then you end up in the same situation as any learning language, leading to it being only used to introduce people to coding.
bad_alloc: just wait till heuristic computing. Then reliably doing simple tasks will be impossible, but complex tasks will mostly come out right. Or manycore computers, which could multitask, if only we could bend the calculations!
Trust me, there is a LOT of room for improvement in programming. As David mentioned, Hypercard is just one proof of that.
Is that saying that one day programming will magically become ‘easy’ for everybody? Of course not. A better analogy is writing. No one ever says that writing is easy, but it does have a lower entry barrier, and most of the public has no problem learning the basics of it (compared to a miniscule percentage of the public that learns the basics of programming).
And yes, even electrical engineering can be made much easier. With this animated (and yes visual) circuit simulation for example, students can quickly learn many of the concepts that are often obscured by layers and layers of math and textbooks in traditional electrical engineering instruction: http://falstad.com/circuit/
Both engineering and computer programming are topics that need to be taught to more people and at all levels of education. Even kindergartners and elementary students can learn some of the concepts of computer science, for example:
Computer Science Unplugged http://csunplugged.org/
and engineering:
http://www.nsf.gov/awardsearch/showAward.do?AwardNumber=1020243
What’s holding back improvements is culture – the culture of education on one side, and the culture of programmers like here on the other. An example of the latter – research actually found that students and programmers had less errors and and easier time programming when the language was case-insensitive. Guido (Python) wanted to make python case-insensitive, but the python community (NIMPY: “not in my python!”) revolted against the idea. And now we are stuck with most new languages still being basically just like the same old C, including javascript, which is unfortunately the ONLY language supported by browsers.
So yes, I understand that programming can be very hard, especially when you are a “programmer writing an Operating System”. I’ve worked on compilers and graphics libraries, and can be very difficult. Try writing a compiler on top of the type system-less javascript, too. But it can be made much, much, much, much easier for folks. You just have to think outside the box sometimes, be very patient (this is a problem that we’ll be working on for decades, not solving overnight), and have a better understanding of how people learn.
With some 40% of Americans BELIEVING that the earth is less than 5,000 years old because that is what the bible says, education, be it computer languages, programming, maths or Evolution will eventually have to fight to be recognised as having ANY validity in this world populated by a sadly growing population with absolute FAITH IN GOD and that all things created by man are either ‘Gods’ or the ‘Devils’, work.
We programmers, scientists and Engineers are the modern day witches.
Give it time and we will be accused of ‘speaking in tongues’ that no one understands and whoof, welcome to the stone age.
NOT as off topic as you might at first consider.
best wishes from the UK.
Nowhere does the Bible say that the earth is 5,000, or 6,000, or even 10,000 years old.
@Jim (May 23, 9:07 pm) — It’s beside the point whether the bible actually says those things, because there are plenty of people who believe it does, and they’re the ones who will lead the witch hunt.
The programming languages we have are actually designed to make programmer easier. They are much simpler and easier to reason about than any other human created languages.
If you try exactly specifying anything in “natural language” you might be surprised by how ridiculously complicated it gets.
Human languages are largely based on context(or assumed context) and we very often get the context wrong. But through additional communication and guessing we tend to fix our issues with context over time.
This is fine if you’re a slow human being who takes a long time to do anything and therefore has lots of time for context issues to be discovered and corrected before too much is done.
I disagree. I do not think Gui based languages will ever work, because it is faster to type. Programming can be easier by developing languages that task more of the work to the compiler. Python is an example of an easy language while C is not. Issues like different data types and input validation (to prevent possible exploits) are two of the numerous problems programmers face.
A person will always have to understand programming logic, but that’s not too complicated to learn.
For you it may be faster to type. Python may be hard for someone yet C can be easy for someone.
With the right editor a GUI-based language could be just as fast as typing, by using keyboard shortcuts and by taking advantage of the graphical nature of things to make some tasks require less explicit information. You should check out Subtext
I guess the author agrees that programming can be continuously made easier and easier… up to a point. Perhaps, it is theoretically possible to improve the programming languages to the point where their constructs express the problem at hand almost in a natural language. But then what? We’re left with the inherent difficulty of the problem itself, and that’s the limit which cannot be passed. Everyday I get tasks from business analysts to do this and that and what they require seems simple enough. But then I start asking them more details about input validation, relationship with other modules, error handling, corner cases etc. and their initial requirements become a pretty complex specification, which is, in itself, hard to put in words with the precision and rigor that a computer needs.
Any area of study requires learning a vocabulary that expresses concepts specific to the area in a concise manner. Computer programming is no different, and has the additional restriction that there must be no ambiguity.
As humans, we can work with ambiguous instructions, clarifications and unstated assumptions. Some times that creates good results, some times bad. But they are not fully predictable. I consider the benefit of computers that they produce predictable results (depending on the quality of the software). As we move towards “machine intelligence” – making the computers more like humans – they will start making some of the same mistakes we do.
Pingback: Top Posts — WordPress.com
Rolonics Theory opens up new possibilities to doing what would otherwise be magic. For example we are already creating applications using an asynchronous templating system which binds fully decoupled Groovy scripts to create applications over a distributed database.
Enabling web developers to create scalable applications is surely a good step forward in making programming easy. Facebook and Twitter beware! 🙂
Pingback: Should Average Joe be Left Out of the Coding World? « SmorgasTech
Good post.. echoes something of Fred Brooks’ The Mythical Man Month (mandatory reading for all IT managers IMHO). As Brooks says, software development’s “essential complexity” is one of the reasons why it can never get any easier.
Our job is to solve complex problems – and once we solve one set of problems a new set emerges. It will never end until the last developer is dead.
Your last subject essentially points out the largest part of programming. The logic in most if not all languages is inherently flawed. It always has been. Programming thinks in a logic which is a few steps below a physicist or mathematician. We just need to elevate programmers to a higher level of thought such as the aforementioned professionals,
Zechariah, the problem has been the theory that programming has been based on. It turns out everything can be thought of in terms of behavior (logic), relations, structure (state, data) and streams (events, tree walking, changes over time–journal entries), not just data and logic.
Once you start building frameworks which support all 4 aspects (streams being the least supported in general), you can adopt a common data structure for all objects (role-based programming) and push everything but the business logic into the framework.
Complexity is preserved–framework development becomes even more difficult. But application programming then becomes entirely focused on the application, as it should be. As it is, every program is largely focused on things which should be framework issues–like scalability.
Haskell (and others like it) is generally at a higher level than physicists, if not mathematicians. It’s just a question of which language you’re using.
Well articulated. Ides help, but it will never be that easy.
Totally agree with your post!Very well put and well written!!Excellent work! 🙂
Haven’t we beaten this “oh soon we’ll built software factories” to death already multiple times? How is it that meme seems to reanimate like a zombie from the dead every handfull of years? (why won’t UML just stay dead already?!)
Anyhow, there is of course an answer to the easy programming problem. It falls into the category of “Make it so!”. For now, this statement is dutifully parsed by actual programmers. But who knows, if we ever get strong AI, maybe we could persuade it to do our mental work for us.
But somehow I get the feeling that if something gets a zillion times smarter than humans, it’ll probably just tell us to bugger off before it get the fly swat.
Well, but it is possible to great a DSL that is for one use case so simple that a layman can understand and use it.
But of course to develop such a DSL is hard work…
There are two types of programs, the casual, application programs you need to write as part of doing a job, and the complex, large programs (OS, compiler etc) that are the job. The second category is obvious that for now needs a programmer to write and debug.
For the application programs, is it possible to write an AI based programming language that interacts with the user in order to write the application program, using questions to disambiguate the natural language ambiguities?
When I say ‘repeat 50 times” is pretty obvious what I mean. When I have two sets of 10 numbers and 50 numbers and want to add them in pairs, the AI could figure that this is not possible and ask questions to see what I really think I am doing.
I have learned, programmed and forgotten more than 15 computer languages in my life. I am getting older and I do not care to have to specify stupid details in an arcane format just to get the computer to do something.
Recently I had to program a Symbian smartphone to to some simple stuff. Amazing how hard it was to just get the camera to take a picture and hand over the picture data.
I always looked at learning programming languages like learning foreign languages. It’s not easy to fully control and takes time to understand. There is a reason it is called a language. It takes a different mindset to sit down and learn. The ones who want it to be easy are the ones to lazy to learn it. ANYONE can already write code with just a few simple tutorials, but not everyone can control the code, and that what takes time and effort. Just as anyone can “speak” a foreign language, but to be fluent takes time and effort.
Hey,
we (programmers) would be unemployed if programming was too easy..!
Let’s not simplify anything. Designers (drag drop of controls, setting properties with dropdowns) are already an insult..!! I see people using dreamwaver dragging and dropping controls all over the place, calling themselves programmers. If you switch them to source view, they get horrified: “oh, but I don’t use that.” (== “I’m not a programmer”).
I’ve been threw MANY programming languages. And… People are probably gonna scream now… But I moved from C to VB as my main language a couple of years ago, and it is now my favorite. I would never go back to C. If you want a nice, readable code that’s not littered with (useless?) semi-columns.. Really, VB is as easy and pretty as I can picture a programming language. We should just get it mainstreamed across platforms (yeah, I know what you’re thinking: but who cares?! Do it anyway..), and build on that.
Hey,
We (Real Programmers) would be unemployed if Real Programming were too easy! Let us not simplify anything. Toy programmers (dynamic typing, garbage collection, even program self-rewriting on the fly given advanced enough toys) are already an insult! I see people using JavaScript, Python, Ruby, VB, whatnot, pretending that computers understand strings, using dynamic dispatch even when it is unnecessary, and not worrying a single bit about the memory footprint or the executable size of their programs. Meh! Their programs do not even compile down to executables!
I have been threw MANY programming languages. And, people are going to scream now, but I have switched from x86 assembly to C as my main language and it is now my favorite. I would never go back again to x86 programming, I mean, if you want nice, readable code that is not littered with those hideous hardware interrupts… Really, C is as easy, pretty and portable as I can picture a programming language. Yes, unless they have specific system calls, my C programs can be compiled on and for every major platform out there; and if I need to do specific system calls, I can nicely wrap them in nice #if…#elif…#end. What was everybody thinking when they developed this mess of incompatible languages?
Well the nice thing about C is that you can generally insert Assembly code if necessary, so it is the best of both worlds. If you really know your compiler and you know that, for example, using c=*(a+b) generates less code than c=a[b], then you know how to take advantage of the language without even using Assembler. But then you would be far about the average so-called programmer.
There are so many languages that aren’t PROGRAMMING languages, which are written with the express intent of diminishing or dumbing-down the technical knowledge needed by the programmer. Business wants this because business does not want to pretend they respect the technical profession. Business does not want to admit that they NEED the programmer, so they use these things like C# which allow functionality with less learning on the part of the “programmer” and therefore the programmer can be more easily replaced.
What the business world has not realized is that by depending upon the language vendor instead of the local programmer’s expertise, they are not relying not on someone’s ego, but on a corporate marketing ethic.
I think this is a disaster waiting to happen.
Almost 3 years, but I’m still going to say: you are wrong. If a person writes program in a dynamic languages (do you really understand what dynamic languages mean?), that doesn’t mean they don’t understand how to write C/C++. If you work with complicated problems that do not have a well defined solution from the beginning, dynamic language is the way to save time to implement unneeded things before they write in in a compiled language.
The concepts behind C, Assembly are not difficult to learn. Instead of wasting time to tackle with x86 trivial manual management details (in which 99% is irrelevant to the problem), you could spend that time to focus and solve complex mathematical or machine learning problems that already have hard to read document with tons of strange mathematical symbols, or an intersting algorimic problems that if you optimze the algorithm, it will run hundred times faster than trivial assembly optimization, given the same amount of time.
Also: http://www.loper-os.org/?p=300
And also learn Lisp and how to write a compiler.
My views have changed a lot since. (Note to past self: You are a big idiot!) But I still despise dynamic languages, because deprive you of the useful freedom to make machine checkable guarantees that your program has certain properties. In return, they give you the useless freedom to write programs that do not make sense!
If you think Lisp is so great, either you have not used Haskell or Standard ML, or you are irredeemably ignorant. I know, I know, Lisp has macros… so what? Why do I need syntactic abstractions if nothing guarantees their semantics will actually make sense? Getting syntax right is the easiest part of programming, after all.
The really hard part of computer programming is coming up with a program that actually means what you want it to mean. As Dijkstra said, this requires using formal logic, and no amount of testing can possibly replace that. And, guess what? Type systems are machine-checkable encodings of logic!
Also, I have written several compilers. In both C++ and Haskell.
And this does not make programming easier? http://www.fastcolabs.com/3016289/how-an-arcane-coding-method-from-1970s-banking-software-could-save-the-sanity-of-web-develop
On Fri, Aug 23, 2013 at 4:40 PM, The Lower Level wrote:
> ** > catnaroek commented: “Also, I have written several compilers. In both > C++ and Haskell.” >
That is not particularly helpful when you need higher-order abstractions. Now, this is a matter of personal taste, of course, but in my experience, the productivity hit from having to describe gazillions of instances of the same abstract concept, instead of describing the abstract concept itself, is too great to be overcome by the apparent simplicity of flowcharts.
My father did some kind of programming most of his work life.
He did the work plans for a factory. You have to detail all the step to make a machine out of the bare metal. You don’t design the machine. That is the job of the engineer. But you have to break it down and plan how the step should be done. Down to the detail a more or less skilled worker is able to understand.
This kind of job could not be done by anyone. And the workers are on a level of language understanding, where computers have ways to go. Since i know this, i know, that there is a lot of room for improvement in programming languages, but there will be room for programmers/planners regardless of the level we are able to reach.
Why will programming never be for the masses?
Ask someone to write down every single step required for brushing your teeth, for example:
1) //Get Tooth Brush
2) Using you right arm, move it exactly 35 cm forward
3) Tilt right hand 25 degrees to the right.
4) Close right hand
5) Using right arm, move it back exactly 25 cm.
6) Tilt right hand 47 degrees.
7) // Get Toothpaste
8) Using Left hand, move it 17 degrees right
9) Move left hand exactly 50 cm forward.
10) …
As you can see this list will get very very long in a hurry and most peeps have no idea what is required to do for even the simplest of tasks. Now… after it is written down and you have verified that you have captured all of the steps to brush a persons teeth, give the instructions to a two year old and then them to follow the instructions exactly as they are written. If they say, “What is toothpaste?” Then you also have to include Toothpaste instructions (write the driver) too. Oh, wait a second; you say the two year old doesn’t want to brush their teeth right now? D’oh, we forgot to add a step that compensates for this.
My point being, most peeps have no clue as to the details that are required to tell the computer how to do the most mundane of tasks and when they find out what is “programming” really is, they hire contractors… 😀 LOL
The problem is seldom that the amount of instructions is big. The problem is more often related to the complexity gap between stating the functional specification of a program (this is complex, but for reasons not related to computing) and devising an algorithm or a set of algorithms that satisfies said specification in a discrete, finite number of steps.
If we also take into consideration the undeniable fact we forget important details when we make specifications, the programmer’s job is made even harder. Each time a forgotten detail is found by the programmer, his work comes to a halt, and he must ask the analyst to finish his job (to produce the specification), before he can resume his own.
Finally, if we add the fact sometimes neither the customer nor the analyst nor actually anybody knows what they want in first place, the job of the programmer is rendered impossible.
I have just read a couple of paragraphs in this article and came to a conclusion that this author have never known what a programming language is.
This article is really a waste. I guess the author might had not write even a single line of program.
A computer does not contain a human brain to understand the language which are easy for us. Actually a programming language is a collection of keywords, logis etc. When we write something using that language then the corresponding compiler will convert it into Assembly code i.e. machine understandable language.
A computer cannot understand something like a “when a user cliks the button open the file browser”. This article can be accepted if it has been published when we were writing programms in c or fortran.
This is the era of VC++, Objective-c, Java, HTML, C# and many languages have the support of .NET framework too. One notable point it when we look at a C# it is quite similar to English. For eg: foreach ( DataRow in DataSet[“TableName”].Rows).
Look at SQL language what is the hard code in it.
When we have to code something for hardware then it has to be done in C language only. Then what will you do. Will you shout at the hardware to understand your language.
If you want something easy then go for some sccripting languages like Java Script, Matlab etc. Why are you blaming the languages when you are not ready to use your brain.
If you do not knoe how to program then seek some other job. Programming has to be tougher because most of the programmers consider programming as a challenge and they are solving problems using programs like playing a chess game.
Mr. Author you can drag and drop a button without a single line of code in this modern era of computers. If you don’t know about these things then just delete this article. This will definitely make programmers angry.
me thinks you completely missed the point the author tried to make
I did’t read what author has written completely. I have commentd for the initial two paragraphs.
Mr. Raja Ravi Varma, you mean you just read the first 2paras and you are out blasting, nay, CRUCIFYING the author this mercilessly? I bet you ar LESS than a drag-and-drop DreamWeaver dude, else you would’ve at least the article to the end b4 jumping into conclusions.
Good programmers are thorough in their attempting to understand what people are saying befor they jump to say:
C# it is quite similar to English. For eg: foreach ( DataRow in DataSet[“TableName”].Rows)
Come on, you can be more intelligent than that!
If you think I need to be more intelligent than that then I would not be saying programming is easy. Only people who never like complex things tend to prevent their intelligence from growth.
I agree that I have exaggerated then but consider the authors thought.
If it has to be like normal English then I would write the
“Create a window with a table view, and then when someone clicks a button, add an entry to the table view”
above line like this too
“Create a window with a table view and then if somebody clicks button1, add an entry to the table view”
so common English cannot be converged with some syntax somehow it has to follow some syntax which will automatically make the program complex again. 😉
hmm… Should Football be made easier so that more people can be good at it? Should the net be taken down in tennis because it’s an inconvenience? People who think programming should be dumbed down for them clearly lack the self awareness to realise that not everybody is good at everything all the time.
Maybe schools should stop handing out participation trophies so children can start learning that failure is n fact an option, hard work is a must, and passion can carry you further than intelligence
I completely agree with you. For every one something will be hard, so it is the induvidual who should develop his/her potential not the game (programming).
This article is talking about taking a 50 foot tennis net and reducing it to a normal sized tennis net. It isn’t about making tennis “easier” but rather removing unnecessary difficulties so that more people could try and play.
@Raja Ravi Varma
Are you available for pantomime from November 2010?
What does that pantomine means?
Why do you need that details? Do you want any audience like me to show some pantomine?
easy programming languages like VB, Python and anyother will definitely lack in performance. But if you write something in c it will be the fastest in execution speed. The only thing that c language does not have is easy Networking tasks.
If it had that we would be still using c. Try to develop an Windows form application in C# and same in VB you will see the dfference in file size and also execution speed.
C isa language that has been developed especially for hardwares so any code will definitely lag in performance rather than C.
Some of you have said that HyperCard is easiest. Check it for performance.
If you wanna do easy programming then my kind advice is that you start from C language then understand all the concepts thoroughly then you can learn any other programming language very easily, even C# will be easy after learning C.
The only difference you will find is Object Oriented concepts other than that most of the things will be common.
Networking tasks are not that difficult in C. What is difficult (or, actually, tedious) in C is Web programming.
C is not a language that has been developed especially for hardware. C was actually considered a high level language when it was invented.
If you (specifically you, not others) want to learn easy programming, discard the operating system and program your own operating system (bootloader included) in assembly. Then you will understand thoroughly how hardware works, and you will be better prepared to pick any high-level language, like C or Pascal.
Awesome! This should be teached on school. =P
What it really adds up to is that the business world still doesn’t acknowledge programming and technical skills as a PROFESSION. Business guys, and by that I mean to include the sales folk and their kin, and the HR people as well, They think that because they manage IT people that they are somehow — let’s face it — superior.
But their not. As this article says, if you don’t understand programming, if you haven’t written code, how would you know? And if you don’t know, are you REALLY in charge?
A few years ago I wrote a small dissertation (see the second comment at http://www.lockergnome.com/it/2007/08/06/what-is-your-definition-of-an-it-professional/) about how the IT field is like the legal field in that it requires a substantial investment in time and money to obtain the necessary skills. A like a lawyer, IT people oftem work for people who lack their skills.
But yet we lack the acknowledgement of being professionals. Probably because of the ego of the Business majors and such has always been to put down the geeky guy or gal. It’s part of their thing.
And that needs to change.
The problem is programing is an art. There is more art involved in programming than pure knowledge. That is why people who are programmers seem a bit off their rocker and have weird thought patterns. Painting is easy pick up a paint brush dab it in paint and push it around the canvas. Poof art is created, and yes my 3 year old creates art every day.
However is it a Michelangelo? No is it going to sell for thousands of dollars? Is it going to be put in a museum? nope.
Same thing with writing programs, no matter how easy we make the process. The end results take practice, and study to become good, and even then there is a “natural” human nature element, that some people are good at sports others thinking, others creativity. It is also this difference that makes humans overall more intellegent. If we all were even based there wouldn’t be challenge and challenge is what bring innovation.
Programming is super simple, can write a program in 2 minutes that displays a message on the screen and randomly picks the text color. about 5 lines of code.
What is difficult isn’t the code its applying human nature to the code. Meaning what color to use, will a user use a menu, or right click context? Then there is the whole process part. What happens when a user types incorrect data into a field. You ask them to enter 2 numbers and you will sum them, well what if they don’t enter numbers? Oh well lets just prevent them from doing it, hmm and we do that how? Oh more code, It is still all really simple, just time consuming and makes it look like the code is complex.
I mean look at .net code
”
That is about as human language as you can get. It really is just abbreviated human language.
in human language it would be.
Create a label with unique id of something, and text of What I want displayed and color the text Red have it run on the server.
it didn’t like the .net tag. lol
I mean look at .net code
“asp:label ID=”something” text=”What I want displayed” forecolor=”Red” runat=”server
I am an Information Technology student from India. My mother tongue is not English. I have been using computers only since 2003. Even I consider programming easier and challenging then why our Author who is programming for some Operating System thinks that programming languages are tough? I could not understand this attitude.
I realize that programming for OS requires lot of knowledge and patience where there are thousands of structures and millions of variables, that is where the interesting part lies. Isn’t it. Even I was writing programs for just simple applications which would have around 100 to 200 lines but after getting used to it my interests for computers have gone up and my desire for learning the core parts of the system has increased. I do not want to show up but this is the attitude what I commonly see among programmers.
Raja, the author is talking about why programming in general (compiler construction, OS programming, Web-based development, cloud-based computing, distributed processing, whatever) will never be as easy for MAJORITY OF THE POPULACE as using mobile phones is.
He is NOT talking about his own personal ego or individual prowess or the number of code source lines per app!
Yeah I agree that. But not everyone is knowing everything. We do not know everything we use. For example we never knew the complex mechanism involved in repairing a car. Then why programming alone should be made easy for everyone. Let people with passion for programming do that.
If my view is wrong pls. correct me.
Yeah I was a bit dumb then.
One more suggestion from my view is if people want to develop programs which are similar to English then will it be appropriate for them to choose Database Management as their programming domain. Because most of the SQL statements are more or less like English. Isn’t that?
It is important for language designers to be humble enough to say “Programming languages are too hard to use. They ought to be easier.” This facilitates the search for better ways of expressing programs. It’s an easy excuse that the problem domain is inherently complex, but not a good one.
We can also get better at teaching programming. Teaching can co-evolve with language, to bring programming to more people.
excellent article!
http://sc2.nibbits.com/assets/starcrack-allin1/
I think your thesis, the programming will never be easy is correct, but your illustration of why misses the point. Programming languages will get “easier”, but this ease will just increase the general expectations that developers and their leaders have of the development process. It’s the same principle at work here as with the well known fact that while a particular technology may make a given task easier, say, writing a memo with a word processor and sending it to 1000 people through email, technology in general has helped to proliferate the number of tasks a person is expected to keep up with and complete.
Improved language design can make solving problems within a certain problem domain simpler, but overall, the industry will always change to create new or expand existing domains so that development will always be too much of a challenge for dabblers. New nuances of the development process that require specialized skill and attention will replace old ones so that competent business leaders will not have the development competence that an experienced developer would have.
As others have stated, software development is really about the art and skill of managing complexities. The language itself is easy, once you get a little experience under your belt (weeks, months maybe?). So, the question for academics and tools developers is how do you make a language (or really, tools in general) facilitate the developer managing huge amounts of complexity?
For example, I think C# is a little clunky for my tastes, but MS does such a good job with their tools to “magically” help you invoke the right method, property, whatever, that managing the vastly complex .net landscape is not too difficult.
Likewise, object oriented languages, in my experience having spent most of my career in old-world procedural languages, have complex and nuanced syntaxes, but they do a great job in helping developers manage incomprehensible amounts of complexity.
In the long run, we’re better off with the less-friendly language that can help us manage complexity.
Pingback: >_bryanallott.net » Programming For Dummies
This is a superb post and may be one that should be followed up to see how things go
A mate mailed this link the other day and I am excitedly hoping for your next article. Carry on on the perfect work.
Wait a minute, what? Programming is easy, programming is logic. Programming is taking a problem and breaking it down into logical steps. It definitely requires a certain type of individual who can visualize the problem, and then begin to break it down. I don’t find programming hard. I do however find it time consuming, and actually I’m kind of glad that others find it hard, we dont want too many programmers!!
Art, for some reason, I cannot reply to your last comment directly, but here I go anyway: I was just trying to make fun of NNM’s VB vs C post.
In that Vb allows those who cannot comprehend pointers (a construct that comes not ffrom any specific language but from the processor instruction set) to construct pretty front ends, I am sure it has some value. But the detriment to languages such as VB and their like is that they give management the delusion that programming ought to be easy and that — since it is SO easy — programmers don’t deserve to get paid like professionals.
I rant a just bit here because, despite advances in so-called easy so-called programming languages, there are still programmers out there with serious real knowledge that get derided because they can’t just “type faster.” By people who don’t have clue 0x01.
Management thinks programming is “easy” because they think that, once a specification is written and well understood, the procedure to construct a correct program from it is merely a mechanical task.
This wrong idea is further reinforced but what managers usually see programmers do: code. Coding is a mechanical activity, and no matter how much we love coding, mere coders actually deserve and will be paid as mechanical workers.
But coding is just a tiny part of what a programmer’s job. The other, and significantly more demanding, task a programmer must perform is devise the algorithm he is going to implement in code. Unless, of course, the employer considers trial and error coding an acceptable alternative.
Devising nontrivial algorithms for previously unsolved problems is a mental exercise that relies heavily on analytical skills. Sometimes, it also requires creativity to connect-the-dots in ways not evident at all. Computer science provides tools that make our lives somewhat easier (as long as the problems we solve are in P), but they cannot bound our search in the space of valid algorithms the way, say, the laws of physics can bound a civil engineer’s search in the space of structures that can hold a given weight without breaking. Because, at its very core, CS is nothing but applied discrete math. And math is boundless, unlike our real world and, thus, unlike physics.
This is, I think, mdmstudio’s original point. And this is a hard fact of life not only we programmers, but also the whole world (increasingly relying on automated systems and, thus, on programmers) has to live with.
It seems to me that the true underlying issue is one of specificity. We take a lot for granted in the context that natural languages attach to things. On a computer, everything is without context. Imagine that someone walked up to you and instructed you, “Create a window.” What would your response be? Almost certainly, assuming you didn’t simply laugh or refuse, you would go into information gathering mode:
– What kind of window?
– Where?
– How big?
– What kind of glass?
– What kind of frame?
– Who will pay for it?
– What is the budget?
The same applies on a computer. If you had a programming language that could comprehend when you said, “Create a window,” that still would not be enough information. All of the above questions (or their equivalents for the GUI framework) would have to be answered, and when writing a program, they all have to be answered at the time the program is written. That is, the program must encapsulate the answers to all of those questions.
Consider, then — which of the following is more readable?
Please create a window, uh, a set of french windows actually, two panes, and I need them in the south wall of my livingroom, and I’d like a frame made of mahogany-stained pine. They should be about 4 feet wide in total and I like tall, narrow windows so let’s make them 5 feet tall. I want them centered vertically in the wall, but they have to be about 2 feet to the right of center horizontally because of where my couch is. My house is energy-efficient, so I’ll need that expensive triple-glazed glass in the frame. Oh, I suppose you’ll need to know what style of frame — I’d like the one that the web site describes as “Intrigue”, it has a nice, sophisticated look to it. I will pay you $250 for the installation, as long as you do a good job, and don’t even start the job if the materials are going to cost more than $1,000.
..or, as expressed in a pseudo-code type of language:
Window window = new Window();
window.Style = FrenchWith2Panes;
window.Location = LivingRoom.SouthWall;
window.Frame = new Frame(Wood.Pine, Stain.Mahogany, Style.Intrigue);
window.Dimensions = new Size(4, 5);
window.HorizontalPosition = LivingRoom.SouthWall.Width / 2 – window.Dimensions.Width / 2 + 2;
window.VerticalPosition = LivingRoom.SouthWall.Height / 2 – window.Dimensions.Height / 2;
window.GlassStyle = TripleGlazed;
window.Quota = new ResourceLimit(1000);
window.Build();
Well, a non-programmer may look at that pseudocode and say, “What on earth is that?!” — but they’re not going to find the gigantic wall of text approachable either. A contractor would look at the wall of text and the very first thing they’d do is turn it into a point-form list.
The job of a programming language is to make the task of specification easier, both to do initially and to subsequently maintain. The wall of text is not easily maintainable, and its structure is disorganized. Making changes to it requires checking preceding and following sentences to ensure that the flow does not become repetitive or that an incorrect context is not inadvertently implied.
A programming language, though, can never make the task of specification obsolete. It will always be necessary to be highly-specific about what you want, because computers do not operate on context, and if they did, they would not reliably perform the same task the same way repeatedly. That is something that we depend upon.
A graphical designer for a form is just a way of very rapidly generating that point-form list of parameters. In older languages, this tended to be written out in a binary format that required a special block of code in the framework for parsing. Modern frameworks, though, almost without exception, literally read and write code like the pseudocode shown above. The designer facilitates the process, makes it easier to specify, but it doesn’t obviate the requirement to specify, and ultimately, the specification itself falls to a language that assigns values to properties.
As long as we have clear ideas about what we want and computers can’t read our minds, that will always be the case, because you can’t get what you want if you don’t communicate that to the computer. In the case of a program, that desired outcome has to be expressed in its entirely as part of the development process; the end user most certainly does not know what they want.
Programming languages will continue to get better and new, simpler ways will be found to express common, repetitive tasks. Consider what XAML and LINQ have done for programming in the C# world; thousands of lines of code are compressed down to a concise expression that is easy to read and easy to make changes to. That concise expression, though, is still a specification, and it is just as precise as the thousands of lines of code. You are still telling the computer precisely what you want it to do; you’re simply given a framework with a bit of predefined context.
Ultimately, that is where the dichotomy lies: computers do not have context, and we rely on it to express ourselves in day to day life. Programmers are people whose brains have been taught to work without context, without external influences on interpretation. Programmers see the details and focus on them without letting things like intent interfere. They need to see and understand what the code actually does, not what was intended to do. The average person has great difficulty doing that, and that is where the skill in programming comes into play.
So, to summarize, computers operate without context because if they assumed context — a context changing over time like that inherent in human communication — then they wouldn’t perform reliably. Because there is no context — can never be implied context — programming languages require detailed specification. Because programming language require detailed specification, they will always require verbosity and intense attention to detail, no matter how they invite the user to express those details.
Well, paying attention to those details still qualifies as a mechanical job. After all, factory workers have to pay attention to details, or else the physical products they produce will have defects. And no one can deny that pretty much anybody, given proper training, can be a factory worker.
What sets apart programming from mechanical tasks such as building houses or coding is the need to devise algorithms. That is the hardest part of programming, and that is what makes us programmers professionals and not mere workers.
Or, well, I might be biased by the fact I am currently working developing a program that generates university timetables. Perhaps the jobs of most other programmers is just mechanically specifying the attributes of a bunch of windows and controls, in which case their job is actually easy, but long, dull and boring.
I didn’t go into it in my original post, and I probably should have — but I meant for the concept of specification to include specification of procedural actions, transitions, of the algorithms that make the software “go”, as opposed to being a static suite of forms that sit, motionless, in the state they were designed. 🙂
The challenge in programming is not in the specification, the challenge in programming is in knowing what to specify — but the original argument that I was addressing had to do with why we don’t have programming languages that let us say simply “Make the window I want.” It would take mind-reading; we have to specify the details.
Unlike creating a programming language that can read minds, solving the other half of the challenge, that of figuring out what needs to be done, is, in theory, actually possible. That is not to say that it is even remotely easy, but sophisticated AI could take over our job in that area. However, that AI would be operating based on context in exactly the same way we do, and it would not, in effect, be providing a “programming language” that permitted statements such as “Make the window I want” or “Do the right thing when that button is pressed.” It would instead be writing code in a language much like what we use today. Ultimately, it still comes down to things needing to be specified.
Came across your site via google the other day and absolutely adore it. Carry on the truly amazing work.
Pingback: links for 2010-09-02 « pabloidz
great post !!! keep sharing… 🙂
Keep Posting Thumbs Up!
Thanks for taking the time to discuss this, I feel strongly about information and love learning more on this. If possible,it is very helpful for me.
Pingback: 编程从来都不是个容易的事儿 | New Start Again
Pingback: 编程从来都不是个容易的事儿 « 编程王网站
I love your blog lots of useful information.All these issues are important, and that’s why I just started blogging a while ago and it feels great.
Nice Information.. Thx for sharing this very usefull for me…Cheers!
Pingback: 這不是秘密，但是爸媽很少這樣想@囧評20100912 – Razorcap Studios
nice blog nice info any good stuff thank you very much well done. i learn step by easy programming
Bookmarked your fantastic website. Really good work, unique writing style!…
Pingback: 编程从来都不是个容易的事儿 | 枫林火山
iris garden pictures,
You really made some good ideas inside your post, “Programming will never be easy The Lower Level”.
I will become coming back to your web page eventually.
Thanks ,Misty
Today, while I was at work, my cousin stole my iPad and tested to see
if it can survive a thirty foot drop, just so she can be
a youtube sensation. My iPad is now broken and she has 83 views.
I know this is entirely off topic but I had to
share it with someone!
If you are going for best contents like myself, just go to
see this site every day as it presents feature contents, thanks
Excellent post. I was checking continuously this blog and I am inspired!
Very helpful information specially the final phase 🙂 I maintain such information
a lot. I was seeking this certain information for a very lengthy time.
Thanks and good luck.
Really excellent info can be found on web blog . “Politics is applesauce.” by Will Rogers.
I am really loving the theme/design of your site. Do you ever run into
any web browser compatibility problems? A couple of my blog audience have complained about my website not operating correctly in Explorer but looks great in Safari.
Do you have any tips to help fix this problem?
Tremendous issues here. I’m very happy to look your article. Thanks so much and I am taking a look ahead to touch you. Will you please drop me a mail?
you are really a excellent webmaster. The web site loading speed is amazing.
It kind of feels that you’re doing any unique trick. Also, The
contents are masterwork. you’ve done a great process on
this subject!
Excellent post but I was wondering if you could write a litte
more on this subject? I’d be very thankful if you could elaborate a little bit further.
Many thanks!
Here’s another way to sum it up: the basic idea is that programming is about understanding systems. We’re not going to stop integrating systems any time soon; if anything, they’re going to get more and more complex, with more and more moving pieces slotted together. Tools evolve to make the slotting of the pieces easier, but understanding the interaction between those pieces will always take a special dedication to the task, and a mind with an aptitude for seeing how all those pieces fit together, or, more importantly, how they sometimes don’t fit together in subtle ways. People who’ve never worked on complex systems (and especially people who’ve never programmed at all) sometimes have this idea that programming is just monkey work, and one day we’ll write a program to do the programming for us and we won’t need programmers any more. Granted, one day we might have a weak AI capable of the type of comprehension human programmers bring to the plate, and then it can take over tasks related to systems engineering, but the simple advancement of the tools we have today will never take that role. Programming well *is* fundamentally a hard task that requires an excellent intellect, concentration & focus, and a desire to continue learning.