But they will be stuck with only the ability to create web apps, iphone apps, word processors, operating systems, video games, network servers, web browsers, text editors, robot control systems, embedded software... oh wait, that's not sounding so bad.
In the business world, there's a significant distinction between a scripting language or not: whether it needs a compiler. This is a very relevant and real distinction for enterprise-scale applications and implementations.
Code being in a scripting language means that the "operations" data center folks can tweak and poke it. Need an extra parameter passed in or a magic constant changed? Just do it. But compiled code is no exaggeration often an order of magnitude harder to maintain. A whole chain of change requests must come into being, from whoever found the need back to a "developer" who has the right tools and environment and access to the source and even knowledge of what and where the source is. (We don't see that kind of problem at the scale of a YC startup or a well-managed Google-size tech behemoth, but organizational tech knowledge is a gigantic problem for companies whose primary problem domain is not tech. Like say a bank or medical provider or retailer.)
I've written significant amounts of code in SQL stored procedures when C# (we're a Microsoft shop) would be a more appropriate platform, simply because my company's culture is that SQL is accessible and open to the business analysts and managers while C# really has a walled-fortress image. It grates on my sensibilities but "scripting" really does save effort in the long run simply thanks to greater transparency.
Back to the original article, it's really just saying that a scripting language has lower barriers to entry and maintainability, which is absolutely true.
True, although the Python compiler operates invisibly and transparently. kbutler makes a good point too. I'll clarify my original distinction: it's whether source code is executable without needing additional tools, and thus the knowledge and environment and dependencies needed to use them.
Calling them such does them a disservice. They're just as "general purpose" as Java, say. The distinction made in this post seems to be more about the problem domain and using a realistic language to tackle it rather than the language itself.
True, but I see it as a defining characteristic of "scripting" languages that they are great at quickly and easily automating everyday computing tasks... Something you would be hard pressed to say about Java. But is there a term that expresses this attribute without seeming to rule out others?
"Scripting languages" fly under the radar, where a corporate regime mandates use of (say) Java. So it's actually a good thing to call something a scripting language. The main downside is it doesn't sound elite, in the programmer hierarchy.
i've lately been espousing the opinion that colleges should add some scripting and data manipulation to gen ed requirements in order to adequately prepare students for the next generation of white-collar work.
then again, i barely remember a thing from my entry-level stats course.
This. My little sister is working at The Economist and will go to Princeton next year to study Developmental Economics. She could work magic with the data she can get from the kiva API or the UK government data website, but she has no easy way to parse it other than nag me (who got a 3rd in CS from UCL) to write a little script in ruby that does it for her.
In part, this is what we're working on solving at Timetric; the skills gap between people who understand the physical nature of data and people who have the domain knowledge to tell you what it means.
Yeah, I've become acutely aware that I'm a product guy. I don't dream in algorithms. Scripting is really good for me, but CS is something I don't like. Scripting solves a problem for me the same way a camera solves a problem for a photographer. For most people, they'll be able to remember the images they produce, and they won't try to create something that means something the same way a photographer would. I'm similar. I create technology that solves an immediate problem for me, rather than some technological piece of mastery.
You don't necessarily have to love algorithms to go through CS.
Personally, I always liked the linguistic aspects of CS--parsing, lexing, compiling and language semantics from the basic theoretical level through the practical aspect (e.g. how they relate to best practices, optimization, and design patterns). But when it comes to the fastest way to implement a sort, you shouldn't come bothering me.
I won't doubt that low-level algorithms are important, but a pure disinterest in them makes me a pretty poor C programmer.
I feel the same way. While creating a cool piece of engineering is satisfying, it is nowhere near as satisfying as seeing real people enjoy the end product. For me, coding is a means to an end, rather than an end itself.
I don't mean to offend you but it sounds like you might not be a great programmer, although you still enjoy the idea of making stuff that's useful (even if it's not written well or a particularly challenging thing to do from a CS perspective).
This sentiment annoys the hell out of me. There are many great programmers (mainly in the web world) that rarely work with algorithms or other traditional CS topics. Just because he says he's product-focused doesn't mean that his code isn't well written.
If it doesn't solve any challenging or interesting problems, in what sense is it well written then? In other words if it's easy to write, it's easy to write well. (I hope we are talking about something more substantial than consistent braces and spacing style here.) I have a difficult time imagining that OP enjoys doing some of the more difficult things that are part of the programming universe: seems like he is interested in applying just enough script to Make It Go.
You mentioned web development: I'm sorry but the majority of what's called web development is writing WordPress themes or Drupal modules, and most of this work is leveraging some API in tedious and uninteresting ways. Create this content type, do this when you save it, make this form, validate it like that, blah blah. A person who writes a plugin in WordPress to do the Nth most routine thing in the world (say, list posts in a particular order, for example) -- something that I have to do from time to time, just like anyone else who writes web-based software -- is merely connecting tubes. (Something I wrote elsewhere.)
The point is this: to be a programmer means a specific thing, and it means more than stringing together statements in a language.
My mom who can write `SUM(A1:A10)` in Excel is not a programmer, even though she can do some fairly complex things in a high-level language.
And most kinds of contract web dev out there is writing the exact same functionality for the Nth time (or integrating someone else's plugin for the Nth time), by typing out the correct sequence of API calls against a commodity CMS. Or the frontend equivalent: embedding some off-the-shelf Javascript slideshow or a Facebook like button.
If this is programming then we have a linguistic deficiency, because it's not even in the same category as the kind of work that goes on at the most innovative startups.
" I'm sorry but the majority of what's called web development is writing WordPress themes or Drupal modules, and most of this work is leveraging some API in tedious and uninteresting ways. Create this content type, do this when you save it, make this form, validate it like that, blah blah. "
You're correct that lots of web development is simple. However, a very large assemblage of simple components is not simple, and lots of web apps are very large. For example: one of the first web projects I worked on was a game written in PHP and MySQL. At first, it went much faster than expected, as writing a basic CRUD app in PHP is very simple. However, as it grew, it turned into an unmaintainable mess, and I got my first lesson in some basic coding standards.
My friend had a good distinction - there's "difficult" projects and "complicated" projects. Something that is difficult might require some clever algorithms and maybe more time spent with a pen and paper than at the keyboard/ Something that is complicated requires a lot of coding, and thus a lot of effort spent in organising that code.
That distinction between difficult and complicated is great, thanks for sharing that. My answer looks arrogant by comparison, because the distinction you shared allows both types of folks to be called programmers.
The relationship between Software Engineering (60% of the most used languages are "scripting" languages) and "running cable," is that they are both concerned with creating direct utility to people. I fully understand and respect that the completely theoretical side of CS might seem more difficult and therefore superior (?) to engineering, just as coding might seem more advanced than "running cable," but I could never see dismissing "running cable" as inferior to writing code. I would also point out that the top 5 U.S. CS programs, for whatever misguided reason, are all very much interested in creating direct utility to people -- through HCI, Software Development, even bad code: http://hci.stanford.edu/research/opportunistic/
No one said that running cable was inferior to writing code. I spent some good afternoons running cable at my house. But it's not computer science. Would you ask any prominent computer scientist about their opinion running cable? At best maybe a EE professor to understand signal dropoff, but it's just not computer science.
It's not about superior/inferior. It's if it is part of CS. Running cable isn't. Writing scripts generally isn't. That's it.
What has solving simplistic little 1-line problems like "Given f(x) = a, what is x?" got to do with mathematics?
Sure, there's other things. I could think of a few bad analogies for recursion, pointers, algorithms, and architecture; but architecture is often badly taught, and the rest are probably easier to grasp if you can do the first step - solving simple problems.
When I graduated with a CS degree in 2003, all of my programming experience was in C/C++. After graduating, I went into web development using scripting languages that were never taught in school. I would have loved to have had classes focused on web development with scripting languages rather than take classes on operating systems and computer architecture. There is nothing silly about that.
If you're bashing together some web scripts for your local HR department in a company of 100 people, yeah, OS and computer architecture isn't very useful.
If you're a professional web developer that is creating web sites that need to be reliable, need to interact with other computer systems, and need to be performant even under heavy load, you will if anything find that your operating systems and computer architecture courses were merely the beginning of what you really needed. You need everything you can get when you're trying to make a web page that doesn't take 4 seconds to load. Learning another language isn't really the hard part of the problem.
And perhaps more importantly, a CS education is applied to programming. Computer Science is a theoretical discipline heavily rooted in mathematics. Computer Science should not be confused with software engineering.
At my university, Software Engineering is a more theoretical course than CS, with no compulsory programming, and indeed no option for programming in year two, except for a Java module in year one, you do have to build a piece of non-trivial software for your final project though.
I was debugging performance problems in high performance websites before I ever began to try to fill in some of my severe holes due to not having taken CS. Thus I can say from first hand experience that a little quantitative thinking is enough to debug many real life performance problems. Absolutely no knowledge of operating systems and computer architecture required.
What kind of "performance problems" are we talking about here? Taking 2 minutes to write to a database because of some poorly indexed tables? Or trying to serve millions of requests in under 100ms each by intelligently leveraging a caching layer?
Maybe these days anyone can just take memcache and use it off the shelf. But the class of solution that memcache represents (or Cassandra, Thrift, node.js or XYZ...) is one that will not typically occur to a non-CS person. There's no basis for even understanding it.
As someone involved in hiring, I look for people who possess the capability to engineer solutions to my problems from scratch, starting with nothing but a solid basis in CS (even if they won't be doing that every day). I don't want just another tube connector (someone whose experience is primarily in leveraging APIs to write trivial but tedious code).
What kind of "performance problems" are we talking about here? Taking 2 minutes to write to a database because of some poorly indexed tables? Or trying to serve millions of requests in under 100ms each by intelligently leveraging a caching layer?
Both, and more. If you have a math background (as I do), it is not hard to pick up enough practical knowledge to be usefully dangerous. Here are a few examples.
Let's turn on internal database tracing just for one web page so we can figure out why certain requests are slow.
What traffic can we move to read-only copies to reduce load on the main database?
We're going to do an Oracle 8 to Oracle 9 migration, let's track every single database request for a day, and then do them again later against a test database at full speed.
At the start of each web page our database driver pings the connection to verify that it is still good. This functionality is essential for failover to work correctly, but due to an internal locking issue it is causing Oracle severe trouble under load. Fix the load issue without compromising our ability to fail over properly.
Ah, there's the resolution then. I would never argue that a strong math background is not easily converted into a very effective computer programmer with little further experience. Please do not go around telling people that they "don't need experience" based on that result; they will not hear "I can get a math background" instead.
What you say sounds obvious, but please let me remind you that you've almost certainly seen people who could not leap directly to those conclusions correctly. I can name names of people where I work with years of experience who still engage in "flail at the problem blindly until it seems to go away". In fact just the other day we observer one programmer created a perfect loop; patched a bug, created a new one, patched that, created another new one, another programmer jumped in to fix that, and then the original programmer patched yet another fix resulting in the exact same source code we had at the beginning of this process, only with another new line. (I am not sure what the degree status of this person is but it doesn't seem to have taken.)
(And I would agree you can learn a lot without formal training, but at some point you're still going to have to learn what that formal training covers. You also have to learn more anyhow.)
I agree that a quantitative background is useful. But you can do a lot without a strong background in computer architecture or operating systems.
That said, I agree that the lack of a CS background leads to holes that need to be filled in the long run. But that is something that can be addressed down the road. It is not a prerequisite.
It sounds like you wanted to study software engineering, not computer science. It's a shame that most universities don't offer both, just as they might offer both physics and mechanical engineering.
My university offers degrees in both Comp Sci and Software Eng. Over the course of a 4 year undergraduate masters programme I think we took maybe 3 different modules (where a module is 1/12th of a year).
But why? If you went to Uni and learned C/C++, you must have picked up whatever scripting language you had to use very quickly. What would have been the point of spending a Uni semester on it?
Why the "scripting" qualifier? Arguably if you are writing code with the intent that it will ever actually be executed, that's not CS, in the same way that designing a car is not physics. So what, though? What something is called ought to have little to no bearing on whether it's deemed useful, or worthy of being taught.
>> With all due concern for not wasting students' time, this is a problem we in CS should willingly accept.
Or, programming skills are good for you, even if you dont do it professionally.