Cameron Laird's
Regular Expressions
Regular Expressions: As Time Goes By
'Have the time? Often, as developers, having the time is difficult. We don't mean just that schedules are hard to meet — though that's true — but that temporal calculations such as, "give up on this look-up if it takes more than ten seconds" or "set a deadline based on a date as entered by the end-user" or "tell the customer that his documents will be shipped after three business days", turn out to be far harder to program than an outsider might expect. Why the complexity? What can we do about it?
August 2004 Regular Expressions: Three Reasons to Pay Attention to AppleScript
Learn AppleScript. Here are three reasons why it's a good time to do so:
July 2004 Regular Expressions: Pyrex Gives Best of Two Worlds
I got a perfect score.
Well, one of us (Kyler) did. And although it was only for the programming part of a single computing course, the story behind that mark is one that'll interest all developers who wonder how many of C's virtues they lose in a move to a high-level language.
May 2004Regular Expressions: Lua Shines
Take a look a Lua.
We write that every few years (most recently in May of 2002) because the Lua programming language is underappreciated, and because it continues to advance despite the comparatively small number of people working on and with it.
This spring, though, is a particularly good time to jump to Lua (the Portuguese word for "moon"), because Version 5.0 and The Lua Book are both better than we expected them to be.
April 2004 Regular Expressions: Rapid Development of An Assembler Using Python
This month, we turn several of those dimensions around, and look at a technique to use a high-level language to develop a lightweight assembler for an architecture that's not in the mainstream. Guest columnist Miki Tebeka of Zoran Corporation illustrates his approach with a model assembly language, which he implements as a Python-coded application. One of the bonuses Python provides is a strong pre-processor.
March 2004 Regular Expressions: Programming Down to the Silicon
Assembly language can be high-level, too. That's what Randall Hyde promotes, and we think he's mostly right.
January 2004 Regular Expressions: Fit makes for good tests
Fit is a clever testing framework Ward Cunningham invented to support the acceptance tests that Extreme Programming (XP) needs. Cunningham also invented the WikiWikiWeb, or Wiki, among many other projects.
September 2003 Regular Expressions: Tcl Renews Itself
Are computer conferences a threatened species?
Are computer programmers?
Yes, and yes, at least some of them, in some circumstances. A lot of action and good times are left for both; their futures will be different from their pasts, though. The Tenth Annual Tcl/Tk Conference (28 July - 2 August 2003, Ann Arbor, Michigan) made this particularly evident.
August 2003 Regular Expressions: Primitive Uploads
Suppose you're stranded on a desert island, or its computing equivalent — you have almost nothing beyond bare TCP/IP connectivity, and you need to quickly set up a dependable uploading mechanism . What do you do?
FTP and SSH don't make it through many firewalls. End users don't have SSH clients, let alone TFTP; too few are WebDAV-enabled. Almost universally applicable, though, despite its microscopic recognition, is HTML 3.0's "file input".
July 2003 Regular Expressions: Is factorization of scripts different?
Programmers refactor programs. Does it make a difference when those programs are coded in the high-level languages "Regular Expressions" features?
June 2003 Regular Expressions: Think about form, write better applications
When software people talk about "architecture", is there meaning behind their words, or is it just polysyllabic hand-waving?
Yes — that is, architectural insight is real, and makes a difference. One of our very first "Regular Expressions" columns (back in 1998), was about architectural notions of "safety".
May 2003 Regular Expressions: Inline Web images
Most Web sites maintain textual and image data separately. It doesn't have to be that way, though, and sometimes it shouldn't be.
April 2003 Regular Expressions: Low-cost PDF
Many of the questions correspondents send us have to do with Portable Document Format (PDF), the main subject of last summer's "Yes You Can" column. This winter's publication of Perl Graphics Programming makes for an apt time to explain more of the possibilities.
March 2003 Regular Expressions: Catching Up
This is our somehwhat-annual "catching-up" installment, where we briefly mention a few of the great stories we haven't had time or space to cover in detail. One recent favorite is Andrew Dalke's Martel regular expression engine. In November, we mentioned that regular expressions (REs) are not universal — there are plenty of problems not solvable with REs, and plenty more not best solved with REs.
February 2003 Regular Expressions: Web Scraping Is Easy
Laird and Soraiz clear up some confusion about Web Scraping.
January 2003 Regular Expressions: Compromises
It's bad to do wrong things, of course. Sometimes it's also good, though. It's time to say a few words about how to compromise in coding, and how doing right sometimes isn't doing best.
December 2002 Regular Expressions: Yorick Plays a Role
Yorick is fun.
Yorick is an "Interpreted Scientific Programming Language". One user, meteorologist Hugh Pumphrey of the University of Edinburg, explains it as "like
interpreted C with graphics". The payoff for Yorick users is the ease with which they can make such pictures as this diagram of the airflow and pressure
regime past a simple airfoil. Scientists justly find these gorgeous.
November 2002 Regular Expressions: The Limits of Regular Expressions
Regular expressions won't work for everything. Laird explains.
October 2002 Regular Expressions: Be Good to Your Objects
Object orientation (OO) isn't the silver bullet it was advertised to be about a decade ago. In fact, there are plenty of programmers who say they're ready to abandon it for either a more procedural or functional style. Before you stop doing OO, though, consider a few ways you might do it better. That's the subject of this month's "Regular Expressions".
September 2002 Regular Expressions: What Is "Embedding"?
The domain of this "Regular Expressions" column is "glue" languages — those that can be "embedded" and "extended". Several recent columns, especially the May column on Lua, have focused on embedding. To help clarify what these words mean when applied to languages, we'll sketch a few examples.
August 2002 Regular Expressions: Yes You Can
July 2002 Regular Expressions: PHP Handy off the Web, Too
May 2002 Regular Expressions: Lua Lights up Telecom Testing
Laird and Soraiz document one company's use of the LUA programming language to meet its cross-platform development needs, including the need for re-entrancy.
April 2002 Regular Expressions: Syntax Checking the Scripting Way
Static syntax analysis is a low-cost way to improve your programs. Laird and Soraiz discuss a variety of code analyzers, paying particular attention to Pychecker for Python.
March 2002 Regular Expressions: Erlang Is Worth a Look
Laird and Soraiz explore Erlang, a functional programming language with deep roots in logic and functional semantics. For writing apps that really have to work every time, Erlang may be the language of choice.
February 2002 Regular Expressions: What You Should Know about Tk
Let's be clear what we're talking about. Tk (http://mini.net/tcl/Tk)is the graphical toolkit maintained along with the core distribution of the Tcl language. Although John Ousterhout, creator of Tcl, sketched a crude version of Tk in 1988, the first one usable outside his laboratory appeared in 1990. Since then, Tk has emphasized portability (binaries are available not only for Unix, but also MacOS, Windows, and even OpenVMS), ease of learning ("Hello, World" is a one-liner), simplicity (Tk is used in many mission-critical and long-running "control panels" that can't tolerate memory leaks or other software surprises), and compatibility with other software (Tk is often the "glue" that reshapes existing programs).
January 2002 Regular Expressions: curl Simplifies Web Retrieval
Laird and Soraiz explore curl, a portable command-line executable for convenient Web retrieval, along with its associated library, libcurl.
December 2001 Regular Expressions: What You Should Know About Perl 6
October 2001 Regular Expressions: What's So Special About Python 2.2?
Laird and Soraiz take a fresh look at Python, an interpreted, interactive, object-oriented, portable programming language that has no rule six.
August 2001
|
