Programming Languages and Computer Code and Scripting. This Category Page

(Some may be listed under other sections. May not be in any particular order, so please check all pages)

Please Help support A Great Portal with a donation. If you find the A Computer Portal useful.

Computer Programming Languages Various. These are sites which may have a number of computer Open Source development website

C#, C Sharp Programming links
Object Oriented Programming
ASP, Active Server Page
PERL Practical Extraction and Report Language
Java/Java Script
HTML, HTML 5, HyperText Markup Language
XML, Extensible Markup Language
PHP Hypertext Preprocessor
Python Programming Language
Assembly, Low level languages
RSS, Really Simple Syndication, BLOGS
Shell Scripting links
.htaccess Files How to .htaccess
C and C++ Programming
F# Programming, F sharp Programming
SQL, MySQL (Structured Query Language; other database links)
SSI, Server Side Includes
CRON (scheduler for running of programs)
Games Programming, coding games
Programming Applications, VBA, (Visual Basic for Applications). Using Applications.
Flash and Shock Wave and ActionScripts
Cascading Style Sheets CSS
AJAX. Asynchronous Javascript And XML
Apache open-source software and Apache Servers. Mod Rewrite
Ruby Programming Language
ColdFusion Programming Language (What's New in ColdFusion 9?)

Comprehensive Blend for Visual Studio training. The most you will ever receive – for Free; you’re welcome! Immediately after the release of Visual Studio 2013, An all-day session with Unni Ravindranathan, the Senior Program Manager for Blend. Who better to walk through, not the new features of Blend, but all the core features of Blend – and the new features, too. In some cases, Blend for Visual Studio 2013 returned some of the features removed in Blend for Visual Studio 2012. But in many cases, it’s just candy tooling for the XAML developer

Programming is terrible—Lessons learned from a life wasted:-

programming is terrible

lessons learned from a life wasted

A Million Random Digits with 100,000 Normal Deviates, from 1955
Sun, 13 Apr 2014 15:31:13 +0100 - A Million Random Digits with 100,000 Normal Deviates, from 1955:
Early in the course of research at The RAND Corporation a demand arose for random numbers; these were needed to solve problems of various kinds by experimental probability procedures, which have come to be called Monte Carlo methods. Many of the applications required a large supply of random digits or normal deviates of high quality, and the tables presented here were produced to meet those requirements. The numbers have been used extensively by research workers at RAND, and by many others, in the solution of a wide range of problems during the past seven years.
Program design in the UNIX environment, by Pike and Kernighan
Sat, 12 Apr 2014 15:30:58 +0100 - Program design in the UNIX environment, by Pike and Kernighan:
Much of the power of the UNIX operating system comes from a style of program design that makes programs easy to use and, more important, easy to combine with other programs. This style has been called the use of software tools, and depends more on how the programs fit into the programming environment how they can be used with other programs than on how they are designed internally. But as the system has become commercially successful and has spread widely, this style has often been compromised, to the detriment of all users. Old programs have become encrusted with dubious features. Newer programs are not always written with attention to proper separation of function and design for interconnection. This paper discusses the elements of program design, showing by example good and bad design, and indicates some possible trends for the future.

There is much to learn from UNIX, both the failures and successes. In particular this paper argues for small well defined functions which can be composed to build larger functionality, and against a slow and steady bloat of features — as Perlis said “If you have a procedure with 10 parameters, you probably missed some.”

Reflections on Trusting Trust, by Ken Thompson
Fri, 11 Apr 2014 15:30:45 +0100 - Reflections on Trusting Trust, by Ken Thompson:
As a programmer, I write programs. I would like to present to you the cutest program I ever wrote.

This is a classic paper on programming and security, about self referential programs called Quines. A quine is a program that outputs its source code

There is a trick to writing quines, so if you’ve never tried to write one, you might want to give it a try before reading this paper.

Quines come in many forms, some are a series of programs which output the next in sequence, like this famous perl spiral. Others are written in multiple languages, like this python and ruby quine I wrote. What Thompson does with their Quine is rather insidious, but I won’t spoil the fun

"You once referred to computing as pop culture. It is. Complete pop culture. I’m not against..."
Thu, 10 Apr 2014 15:30:51 +0100 - “You once referred to computing as pop culture.

It is. Complete pop culture. I’m not against pop culture. Developed music, for instance, needs a pop culture. There’s a tendency to over-develop. Brahms and Dvorak needed gypsy music badly by the end of the 19th century. The big problem with our culture is that it’s being dominated, because the electronic media we have is so much better suited for transmitting pop-culture content than it is for high-culture content. I consider jazz to be a developed part of high culture. Anything that’s been worked on and developed and you [can] go to the next couple levels.

One thing about jazz aficionados is that they take deep pleasure in knowing the history of jazz.

Yes! Classical music is like that, too. But pop culture holds a disdain for history. Pop culture is all about identity and feeling like you’re participating. It has nothing to do with cooperation, the past or the future — it’s living in the present. I think the same is true of most people who write code for money. They have no idea where [their culture came from] — and the Internet was done so well that most people think of it as a natural resource like the Pacific Ocean, rather than something that was man-made. When was the last time a technology with a scale like that was so error-free? The Web, in comparison, is a joke. The Web was done by amateurs.


- From Interview with Alan Kay, the second grumpiest programmer in the world. (The first is Ted Nelson).
Object-Oriented Programming Versus Abstract Data Types, by William R. Cook
Wed, 09 Apr 2014 15:31:01 +0100 - Object-Oriented Programming Versus Abstract Data Types, by William R. Cook:
This tutorial collects and elaborates arguments for distinguishing between object-oriented programming and abstract data types. The basic distinction is that object-oriented programming achieves data abstraction by the use of procedural abstraction, while abstract data types depend upon type abstraction. Object-oriented programming and abstract data types can also be viewed as complementary implementation techniques: objects are centered around the constructors of a data abstraction, while abstract data types are organized around the operations. These differences have consequences relating to extensibility, efficiency, typing, and verification; in many cases the strengths of one paradigm are the weaknesses of the other. Most object-oriented programming languages support aspects of both techniques,not a unification of them, so an understanding of their relative merits is useful in designing programs
"we write everything small, thus saving time", or perhaps...
Tue, 08 Apr 2014 15:30:53 +0100 -

"we write everything small, thus saving time", or perhaps UNIX’s lowercase traditions go back to the bauhaus.

On the Notion of Inheritance (1996) by Antero Taivalsaari
Mon, 07 Apr 2014 15:30:45 +0100 - On the Notion of Inheritance (1996) by Antero Taivalsaari:

One of the most intriguing—and at the same time most problematic—notions in object-oriented programming is inheritance. Inheritance is commonly regarded as the feature that distinguishes object-oriented programming from other modern programming paradigms, but researchers rarely agree on its meaning and usage.

Yet inheritance is often hailed as a solution to many problems hampering software development, and many of the alleged benefits of object-oriented programming, such as improved conceptual modelling and reusability, are largely credited to it. This article aims at a comprehensive understanding of inheritance, examining its usage, surveying its varieties, and presenting a simple taxonomy of mechanisms that can be seen as underlying different inheritance models.

Inheritance, like OO is one of those concepts that is ill-defined, with a variety of different implementations and uses. This paper is an excellent summary of the different forms and uses of inheritance. Delegation vs Composition, Subclassing vs Code-Reuse, Late vs Early binding, and various other technicalities often glossed over.
I reckon your message broker might be a bad idea.
Fri, 28 Mar 2014 22:50:00 +0000 -

As a curmudgeon, I am often full of reckons. A reckon is often confused for an opinion, but it’s more like a heuristic. It isn’t always true in theory, but it’s often true in practice. Today’s reckons are about message brokers.

They are used by inexperienced programmers to glue systems together. Although they are easy to set up and to get going, when they fail, they take the entire application with them — a broker is often trading convenience for a central point of failure.

Before you start throwing away your working code base, I want to ask you a few questions: What do you do when the broker fails? What happens if a message isn’t handled? What about consumers or producers crashing? Knowing the answers to these, are the first steps to understanding if your broker is helping or hurting your system.

To show how a broker can hurt, let’s look at a classic use: running tasks in parallel over a cluster of machines. In particular, I encountered problems while working on a distributed web crawler built around a message broker.

The crawler starts from a seed list of URLs, pushing them into the broker, meanwhile a number of workers pull out pages to crawl and then push any found links back through the broker, into the crawler. Both the workers and crawler were run by hand. Simple enough, but we encountered many failure cases.

If a single worker died, it would take the task with it, we could resend after a timeout, but if the task froze the worker, eventually all of the workers would halt. If enough workers died the queue would fill up unknowingly and collapse, or worse, the crawler would sit idly for days, not realising anything was broken. When the crawler broke, a similar process happened. The workers would churn away for hours, racking up cpu time to no avail. Occasionally, we could restart the workers or crawler, and everything would be fine. Sometimes we’d have to reset the queues, throw away the work and restart. These failures cost us a lot of money, and an awful lot of time, things a small company didn’t have an abundance of.

The more experienced engineers amongst you will know what we had done wrong. Brokers are a great way of isolating components in your system, and unfortunately we’d isolated the crawler and workers from finding out if something had failed.

There are many ways to fix this: We can set a hard limit on the queue, or a maximum rate of messages, or even set a time to live on the messages. Introducing back-pressure in the system would allow errors to propagate quicker, saving us some time. Another complementary technique is to add acknowledgement messages, allowing the crawler to know when a job was accepted, and heartbeat messages to know that the job was still ongoing.

Instead, we got rid of the message broker.

The crawler communicated with the workers directly, and managed the worker pool. When launched by the crawler, workers would poll the crawler for work, sending all of the results back. If a worker failed, the crawler would notice, and kill the remote process. If the crawler failed, the workers would terminate. At all times, the crawler knew which machine was doing which task. At last, something in the system was responsible for handling failure, beyond the already stretched operations team.

At this point, the canny reader will shout “Ha! But there is queueing going on here”, and sure enough, there was. Instead of a queue hiding away in the middle of the network, we’d pushed it into the crawler. There was still messaging too, but we were just using TCP.

We’d ignored and subsequently embraced three good design principles for reliable systems: Fail fast, Process Supervision, and the End-to-End principle.

Fail fast means that processes give up as soon as they encounter failure, rather than ambling on and hoping for the best. Process supervision means that errant components are watched and restarted. These two principles alone account for much of the reliability of Erlang/OTP. On the other hand, The End-to-End principle is why TCP works.

TCP gets reliable delivery over an unreliable system by getting the hosts to handle missing or broken messages, rather than burdening it with the routers. Handling things at the edges covers problems in the middle. We’d done something similar, pushing the queue inside the crawler: what was now responsible for handing out work was now responsible for handling when it failed.

Not every queue was like ours, although i’ve encountered a few. A similar pattern emerges when brokers are persistent: The temptation is to avoid storing messages at the ends, and when the broker fails, all of the new messages are lost. When you restart the broker, the system still doesn’t work until the backlog of messages is cleared.

In the end, it isn’t so much about message brokers, but treating them as infallible gods. By using acknowledgements, back-pressure and other techniques you can move responsibility out of the brokers and into the edges. What was once a central point of failure becomes an effectively stateless server, no-longer hiding failures from your components. Your system works because it knows that it can fail.

Remember the golden rule of reckons: It depends. Engineering in practice is not a series of easy choices, but a series of tradeoffs. Brokers aren’t bad, but the tradeoffs you’re making might not be in your favour.

To Wash It All Away — James Mickens’ final usenix column.
Sun, 09 Mar 2014 03:17:56 +0000 - To Wash It All Away — James Mickens’ final usenix column.:

Mickens takes on the rubix cube made of razor blades that is modern web development, with his usual panache and cutting wit.

Things You Might Not Know — The Miura Fold. I talk to Tom Scott...
Fri, 21 Feb 2014 14:16:00 +0000 -

Things You Might Not Know — The Miura Fold.

I talk to Tom Scott about one of my favourite origami models — The miura fold.

For those who want to try this at home, here is how to fold it.

Scratch: Programming for Everyone
Mon, 17 Feb 2014 16:06:47 +0000 - Scratch: Programming for Everyone:

What happened to the initial enthusiasm for introducing programming to children? Why did Logo and other initiatives not live up to their promise? There were several factors:

  • Early programming languages were too difficult to use. Many children had difficulty mastering the syntax of programming.
  • Programming was often introduced with activities (generating lists of prime numbers, or making simple line drawings) that were not connected to young people’s interests or experiences.
  • Programming was often introduced in contexts where no one had the expertise needed to provide guidance when things went wrong – or encourage deeper explorations when things went right.

Papert argued that programming languages should have a low floor (easy to get started with) and a high ceiling (opportunities for increasingly complex projects over time). In addition, we believe that languages need wide walls (supporting many different types of projects, so that people with different interests and learning styles can all become engaged). Satisfying the triplet of low-floor/high-ceiling/wide-walls hasn’t been easy.

Programming with building blocks.
Mon, 17 Feb 2014 13:57:11 +0000 -

Over the last six months, I’ve probably spent more time programming in Scratch than any other language, and despite the limitations it’s rather lovely to program in. I’ve made a lot of little games, toy examples, as well as operator precedence parsers (the latter was one of the more painful exercises).

Scratch isn’t really like other programming languages. For a start, it comes with a sandbox of its own: there is a stage with sprites that can move around and interact with each other, as well as being able to insert pictures and sound. However the biggest difference is how programs are assembled — from building blocks, not from text.

With scratch you build programs from square-ish building blocks, snapping them together inside the editor. Programmers in Scratch never receive a syntax error — No missing semicolons, no unmatched braces. There isn’t any tabs versus spaces palaver either, and it’s wonderful.

Block based programming is very similar to what Bret Victor calls “Sentence based configuration” in his excellent essay Magic Ink: Information Software and the Graphical Interface. The entire essay is worth a gander, but we’re interested in the case study on building a train journey planner, in particular how the application can be configured:

A typical design would use a preference dialog or form that the user would manipulate to tell the software what to do. However, an information design approach starts with the converse—the software must explain to the user what it will do. It must graphically express the current configuration.

For presenting abstract, non-comparative information such as this, an excellent graphical element is simply a concise sentence.

Scratch, albeit visual, is still a language built around sentence fragments. Instead of using punctuation and assorted ascii art to enchant text into code, the structure and action of a Scratch program is almost as clear as prose. By using natural language fragments instead of magic identifiers in text, Scratch is unique in another aspect — Internationalization — Scratch programs can be built up out of German, French, Chinese, Japanese fragments too.

The look on peoples faces when you change scratch into their native language is worth treasuring, an aha moment where the code becomes readable in an instant. Scratch is so readable that it has come as a surprise to some, one remarking “I understand this. It can’t be programming”.

Block based programming isn’t without drawbacks. The back and forth of dragging and dropping becomes tiresome, and in Scratch, it’s hard to share code and reuse fragments without duplication. The underlying abstract language isn’t too powerful either — using strings and lists is rather unpleasant for more than the most trivial tasks. I don’t think programmers at large are going to throw away their text editors, or stop arguing over tabs, spaces, or semicolons.

Block based programming is still aimed entirely at beginners, but I’d really like to see how it can grow to encompass more experienced programmers — especially incorporating features from modern IDEs like auto-complete, or refactoring tools. Extending the vocabulary would be useful too — one notable descendent of Scratch, Snap!, adds first class lists, first class procedures, and continuations.

Maybe one day we’ll abandon our text adventures.

Lowering the Barriers to Programming: a survey of programming environments and languages for novice programmers
Sat, 15 Feb 2014 17:59:23 +0000 - Lowering the Barriers to Programming: a survey of programming environments and languages for novice programmers:

“Since the early 1960’s, researchers have built a number of programming languages and environments with the intention of making programming accessible to a larger number of people. This paper presents a taxonomy of languages and environments designed to make programming more accessible to novice programmers of all ages. The systems are organized by their primary goal, either to teach programming or to use programming to empower their users, and then by the authors’ approach to making learning to program easier for novice programmers. The paper explains all categories in the taxonomy, provides a brief description of the systems in each category, and suggests some avenues for future work in novice programming environments and languages.”

We Need To Talk About Binary Search.
Mon, 10 Feb 2014 03:20:45 +0000 - We Need To Talk About Binary Search.:

Binary search is the classical algorithm which is easy to describe, but hard to implement well.

It’s a basic divide and conquer algorithm to find the position of an element within a sorted list: Pick a pivot element in the centre of the list, and either the pivot matches, or the element must be above, or below it in the list. Repeat ad nauseum and return the position, if found

The article suggests an elegant reframing of binary search: Instead of thinking of it as searching for the position of an element within a sorted list, they break it into two problems: searching for the first position, or final position of an element in a sorted list. As a result, the code is much simpler to reason about.

Hello, I am tef. I am available for hire.
Fri, 07 Feb 2014 17:54:00 +0000 - Hello, I am tef. I am available for hire.:

If anyone is looking for a no-good, terrible programmer, I will be available for work soon. I like working on algorithms and data structures, so i’m better at writing code for machines to speak to each other, than user-facing code.

I’ve come to the end of my time at Code Club, as I managed to solve more problems than I caused. We’re hiring someone to take on the web development role, and soon we’ll be hiring people write more projects too.

You’ll note by my spartan CV that I’m not the best fit for front end heavy work, so I’ve opted to take a step back from Code Club to let someone else lead the way forward. It’s been awfully fun at Code Club, and I will miss it.

I am excited to find out what’s next for me, and for Code Club too. I still deeply care about education, but it’s not the only thing I want to change.

Startup Ketamines — Demotivational motivational posters for “startup culture”
Wed, 15 Jan 2014 23:58:49 +0000 - Startup Ketamines — Demotivational motivational posters for “startup culture”:

Earlier today I saw a website (Startup Vitamins) selling “motivational posters” for startups. I figured we needed a little more honesty in the posters, before giving up and playing with a cat.

Tom Scott has transformed them into lovely A4 sized posters, which are free to print if you use the office printer.

"miniKanren is the principal member of an eponymous family of relational (logic) programming..."
Wed, 15 Jan 2014 23:08:14 +0000 - “

miniKanren is the principal member of an eponymous family of relational (logic) programming languages. Many of its critical design decisions are a reaction to those of Prolog and other well-known 5th-generation languages. One of the differences is that, while a typical Prolog implementation might be thousands of lines of C code, a miniKanren language is usually implemented in somewhere under 1000 lines. Though there are miniKanren languages of varied sizes and feature sets, the original published implementation was 265 lines of Scheme code. In those few lines, it provides an expressiveness comparable to that of an implementation of a pure subset of Prolog.

We argue, though, that deeply buried within that 265-line miniKanren implementation is a small, beautiful, relational programming language seeking to get out.


- ÎĽKanren: A Minimal Functional Core for Relational Programming
Papert's Dreams and our Grim Meathook Reality
Sun, 12 Jan 2014 05:21:00 +0000 -

In “Meanwhile, at”, Bret juxtaposes the ideals of Seymour Papert and the dreams of entrepreneurs and venture capitalists. Papert wanted to use programming as a way to let children explore powerful ideas and let their imagination run wild. The agenda of the political, wealthy, and powerful is to build a new generation of worker bees to fuel their startups. One sees code as a liberation, and the other as a vocation.

I’ve talked about these sorts of things before. I see code as a medium for design, engineering, science, art and play, and a computer as a lever long enough to move the world. Which is why I’m thankful for tools like Scratch and the work of the lifelong kindergarden group at MIT. They’re not the only ones trying to Revive Papert’s Dream–

[In Papert’s first article about LOGO “Twenty Things to Do with a Computer” he] described how children might program computers to control robots, compose music, create games, draw recursive pictures, and do many other creative activities.

It was a radical vision. At the time, in 1971, computers still cost tens of thousands of dollars, if not more. The first personal computers would not become commercially available for another five years. Yet Papert foresaw that computers would eventually become accessible for everyone, even children, and he wanted to lay the intellectual foundation for how computing could transform the ways children learn and play.

Some aspects of Papert’s dream have become a reality. […] At the same time, important elements of Papert’s dream remain unfulfilled. Papert envisioned a world in which children not only learn to use new technologies, but become truly fluent with new technologies. In Papert’s view, children should be able to design, create, and express themselves with new technologies. Rather than just interacting with animations, games, and simulations, children should learn to program their own animations, games, and simulations — and, in the process, learn important problem-solving skills and project-design strategies.

Despite the naysayers, to me programming is the ultimate sandbox game. Which is why I want to put these tools in the hands of children just to see what wonders they create, following in the footsteps of Seymour Papert. Just like Mitch Resnik

[After a] keynote presentation at a major educational technology conference, someone asked: “Wasn’t Seymour Papert trying to do the same things 20 years ago?” The comment was meant as a critique; I took it as a compliment. I answered simply: “Yes.” For me, Seymour’s ideas remain as important today as when he published his first article about Logo in this magazine in 1971. His ideas continue to provide a vision and a direction for my research. I will be happy and proud to spend the rest of my life trying to turn Seymour’s dreams into a reality.

I want to dream bigger — Code is just one way to revolutionise education, putting powerful ideas in the hands of the next generation. It’s never been about the code, but the learning through play.

Getting away with rewriting code from scratch.
Sat, 11 Jan 2014 23:25:19 +0000 -

Joel Spolsky’s oft cited tribute to the sunk cost fallacy, Things You Should Never Do, Part I, extolls the follies of starting from scratch. With a length less than one percent of a Steve Yegge ramble, and with almost as much nuance as a tweet, he warns people about the dangers of starting afresh–

They did it by making the single worst strategic mistake that any software company can make: They decided to rewrite the code from scratch.

When you throw away code and start from scratch, you are throwing away all that knowledge. All those collected bug fixes. Years of programming work.

You are throwing away your market leadership. You are giving a gift of two or three years to your competitors, and believe me, that is a long time in software years.

The reality of Netscape’s demise isn’t so simple, as jwz elaborates in the excellent piece Groupware Bad–

See, there were essentially two things that killed Netscape (and the real answer is book length, so I’m simplifying greatly, but)

  1. The one that got most of the press was Microsoft’s illegal use of their monopoly in one market (operating systems) to destroy an existing market (web browsers) by driving the market price for browsers to zero, instantaneously eliminating something like 60% of Netscape’s revenue. Which was, you know, bad.
  2. But the other one is that Netscape 4 was a really crappy product. We had built this really nice entry-level mail reader in Netscape 2.0, and it was a smashing success. Our punishment for that success was that management saw this general-purpose mail reader and said, “since this mail reader is popular with normal people, we must now pimp it out to `The Enterprise’, call it Groupware, and try to compete with Lotus Notes!”

    To do this, they bought a company called Collabra who had tried (and, mostly, failed) to do something similar to what we had accomplished. They bought this company and spliced 4 layers of management in above us. Somehow, Collabra managed to completely take control of Netscape: it was like Netscape had gotten acquired instead of the other way around.

    And then they went off into the weeds so badly that the Collabra-driven “3.0” release was obviously going to be so mind-blowingly late that “2.1” became “3.0” and “3.0” became “4.0”. (So yeah, 3.0 didn’t just seem like the bugfix patch-release for 2.0: it was.)

Ignoring Microsoft’s sneaky tricks, the root problem Netscape had was abandoning code that worked, not rewriting it. Although for Netscape a rewrite helped in their demise, Microsoft made a similar mistake in letting Internet Explorer languish, while a rewrite (Firefox) gained traction.

You can rewrite old Code, but the old Code still needs to be maintained, and migrations should be slow and steady. In my short life as a programmer, I’ve managed to rewrite two codebases without destroying the future of the company by following this simple dogma.

There are good, and bad reasons for rewriting code. jwz’s CADT model aptly sums up the bad, but sometimes rewrites are good because it is too expensive to add a feature to existing code, or the depth of the changes are *highly* invasive. Sometimes it is that the old code is a lovecraftian horror.

The reason is that they think the old code is a mess. And here is the interesting observation: they are probably wrong.

Sometimes, the code is a genuine mess. I replaced a VB6/XSLT horror with something less grotesque in python, with the added benefit that we could now test code before deploying it.

In another instance, the code relied on amazon web services, and now obsolete unmaintained libraries. The project needed to work outside of amazon, and on a new platform. The code itself was littered with customer specific hacks and fixes which weren’t necessary for the new project. Starting afresh with hindsight allowed us to build a system where we could keep these one-off tweaks contained and separated.

In both cases, the old code was still maintained, and many years on, the old code is still running in production. However, the new code now does the overwhelming majority of the work. Migrations are done slowly, one at a time, and usually when it breaks in such a way that only the new version can handle it.

Total rewrites can often be better than rewriting a substantial chunk of your code too. In Interesting bits from “An Analysis of Errors in a Reuse-Oriented Development Environment”, MononcQc (or Fred), neatly sums up some studies on the effectiveness of rewrites–

if you need to rewrite more than 25% of a piece of code, rewriting it from scratch may be as good of an option when it comes to errors and defects.

Rewriting your code from scratch could be the single biggest mistake you make, but equally so, not-rewriting your code could lead to the same result. The old saying “There are only two types of software, failures and legacy code” still has some truth in it. Even if you do decide to rewrite things, the old code won’t disappear overnight.

Programming the weird machine — About 31 minutes in there is a...
Wed, 08 Jan 2014 11:12:00 +0000 -

Programming the weird machine — About 31 minutes in there is a demonstration of a fun a glitch in Super Mario World. By connecting up a bot to a console and faking the controller inputs, one rather canny person manages to execute arbitrary code.

Roslyn® from Microsoft ®. Roslyn is a set of compiler APIs that provides you with full access to every stage the compiler moves through. Roslyn, C# and Visual Basic code are now scriptable. That is, there’s a scripting engine available in Roslyn into which you can input snippets of code. This is handled via the ScriptEngine class. When Roslyn parses a piece of code, it returns an immutable syntax tree. This tree contains everything about the given code, including trivia such as spaces and tabs. Even if the code has errors, it’ll still try as best it can to give you as much information as possible. Roslyn forums to post questions, or use the #RoslynCTP tag in a Twitter post. There’s also a sample called SyntaxVisualizerExtension when you install the bits, which is an extension for Visual Studio. As you type code in the IDE, the visualizer automatically updates with the current version of the tree.. There are tools in Visual Studio, such as Code Analysis, that can analyze your code and inform you of potential problems but runs its rules after thel compilation is completde Now to know as soon as typing that my new code has a mistake in it according to my standards. Microsoft “Roslyn” CTP. Visual Studio Blog. The official source of product insight from the Visual Studio Engineering Team. The CTP and supporting materials can be downloaded Roslyn here

Intro to Source Control: A Must-Have Tool for Programmers    Rachel Morris YouTube Channel  

What is this "Source Control" thing, and why you should use it?

Want to see some examples of repositories? You can view Rachel J. Morris open source projects here

Linux     More Linux Links and Information

id software games      More Games Programming Links

Frogatto (Platformer)

Ruby on Rails      More Ruby Links


Join Rachel J. Morris game development community!

IRC Rachel J. Morris

The Moosader community even has a CC artwork directory!

Moosader news & events on Google+ (Keep up with news)



Support Moosader by buying a fancy T-shirt

Moosader Main Site. (Rachel J. Morris)

Thank you for watching and being awesome!    Be Excellent to Each Other!


3D Printer Software. Software for 3D Printers. 3D Printer Programs. Three dimensional printer software. 3D Printers. Three dimensional printers. Printing Physical Objects. Making things by printing them out. Fast prototype, fast prototyping

Windows 8 App Code Samples. This sample pack includes all the app code examples developed for Windows 8. The sample pack provides a convenient way to download all the samples at once. The samples in this sample pack are available in C#, C++,, VB.NET, and JavaScript. This pack may be very large and take some time to download.

Free eBook: Programming Windows 8 Apps with HTML, CSS, and JavaScript. Now with new, updated companion content, this free ebook provides comprehensive coverage of the platform for Windows Store apps. With added chapters on live tiles, notifications, background tasks and transfers, networking, devices, printing, WinRT, (Windows Runtime). More Cascading Style Sheets CSS and TML, HTML 5, HyperText Markup Language

MicroSoft The Security Development Lifecycle. The Security Development Lifecycle (SDL) is a software development security assurance process consisting of security practices grouped by seven phases: training, requirements, design, implementation, verification, release, and respon

MSDN, Microsoft Development Network, Downloads. Programming Languages Programming Examples and Programming Tips. . Downloads are about getting the latest bits quickly and easily for the product that you're interested in. Download free versions of various products (either feature or time-limited, in many cases), or get the latest updates to key products.

Visual Studio 11 Programming Language Advances. Take a look at upcoming enhancements in Visual Studio 11 to JavaScript, C#, Visual Basic, C++, F#.

Visual Studio 11 .NET Advances. Take a look at some of the improvements in performance, networking, and interop that have gone into the .NET Framework 4.5 Developer Preview.

Compiler Security Enhancements in Visual Studio 11 For the first time, we intend to provide a central mechanism for enabling additional security support via a new /sdl switch, which causes SDL mandatory compiler warnings to be treated as errors during compilation, and enables additional features such as increasing the scope of stack buffer overrun protection and initialization or sanitization of pointers in a limited set of well-defined scenarios.

Game Debugging in Visual Studio 11. Metro style games and graphics-intensive apps present a huge opportunity for developers on new devices such as tablets. More Programming Games links

Visual Studio 2010.   Visual Studio 2010 and .NET Framework 4 focuses on the core pillars of developer experience, support for the latest platforms, targeted experiences for specific application types, and core architecture improvements.

Visual Studio 2010 Productivity Power Tools A set of extensions to Visual Studio Professional (and above) which improves developer productivity. In this third major release of the Power Tools we have made significant improvements to the Solution Navigator and the Tab Well to address our top customer requests.

Visual Studio Gallery provides quick access to tools, controls, and templates to help you get the most out of Visual Studio. Products and Extensions for Visual Studio. The Visual Studio Gallery provides quick access to tools, controls, and templates to help you get the most out of Visual Studio.

Learning Visual Studio. Helpful resources to build your skills with Visual Studio whether you are a beginner or a seasoned pro. Features How Do I? Videos for Visual Studio Videos designed for Visual Studio 2010 developers, from novice to professional. This set of short videos will help guide you through common scenarios, features and functionalities.

Learning Windows Development with Quickstarts and How to’s

Visual Studio 2005 Toolbox Manager This application was developed to be a useful utility that makes it easy to install or uninstall user controls to the Visual Studio 2005 toolbox. The Toolbox utility is a single executable which processes one or more tasks via the command-line. Since the Toolbox itself can change depending on whether you are working with Desktop Framework 2.0 or Compact Framework 2.0 applications, different commands exist which let you add desktop or mobile device controls.

HDI, How Do I...?" Microsoft®,(mainily programming), how to video's. These short 10- to 15 minute videos focus on specific tasks and show you how to accomplish them step-by-step using Microsoft products and technologies. More Help Video's about Computing Computer tips watch and discover. Learn about computers

Free Ebooks from Microsoft Press on Microsoft Virtual Academy, (MVA).. From technical overviews to drilldowns on special topics, free ebooks are available in PDF, EPUB, and Mobi for Kindle formats, ready for you to download. Take advantage of these great resources, and be sure to check back - more books will be added as they're released. More eBook links

HelpNDoc provides all the tools necessary to write complete help files, manuals, documentations and eBooks in a user friendly and very easy to use environment. HelpNDoc can generate standard Windows CHM help files, WEB based documentation, iPhone specific websites, printable PDF and Word documents as well as ePub and Kindle eBooks. HelpNDoc is completely free for personal use and evaluation purposes. More PDF, Portable Document Files links, Mobilephone Programming. Developing Mobile Apps.and Mobilephone Apps Links

Programming Items from Amazonalt.

   Video Tutorial Zone Video Search, Programming Languages and Computer Code and Scripting, etc.

Runnable. Make it easy for other developers to run, edit and share your code examples and projects. Enable organic discovery and adoption for your API, library or project. Add code that shows how your product or service solves a problem for developers. They'll find it, run it and hack away at it instantly. Developers hate scanning through documentation. Give them easy-to-understand code that they can modify and run without leaving the browser. Learn the full picture on how developers want to use your API, library or project thru metrics collected from real code interactions on Runnable.

Most Pressed Keys when programming, Heat Maps of key press use with diff rent coding languages. What happens when having to deal with the different syntaxes, does the syntax allow you to be more expressive or faster at coding in one language or another.Whch keys are pressed most when writing with different programming languages.  More about Heat Maps

Computer Programming Languages Various. These are sites which may have a number of computer Open Source development website

Programming Applications (VBA)        Microsoft Windows Operating System

Other Computer Programming Resources (CSS, .htacess, Hex, Binary and ASCII codes etc...Computer Programming Cheat Sheets)

Web Masters. Click Here Now to start making money. A Great opportunity to make some money. Receive 50% by offering your users Ton's of Keywords on A Great Portal websites. Our Affiliate Program Pays you 50% on Level 1 of Every Sale of our Text Link both searchable and static Text Link!

 Compare Bargains. Enter the Bargain to search for.

Assume that Cookies are stored when accessing any web site or links to to the web sites from these web sites.

Back to top ® © ™ are owned by respective authors and websites. There may be a charge for some software. Always perform an Anti-Virus Check on any Software

You are on This Category Page

Home     Next Page in this Category