Tag Archive for ‘programming’ at Ramblings

Tag Archive for 'programming'

12Sep08 Class is Class, and Instance, Instance, and never the twain shall meet

2 Comments

More about methods, it’s inspired/spurred by a comment on methods, public_methods, and private_methods by Pit Captain. It also corrects some misconceptions I had (and may have (wrongly) given others).

I’ve added a new category, “eating crow” for this and any other postings where I step back and re-evaluate my posts. This is to keep me honest, and, if y’all would, please feel free to tell me when it’s time to “eat crow”.
Continue reading ‘Class is Class, and Instance, Instance, and never the twain shall meet’

11Sep08 methods, public_methods, and private_methods

programming ruby tips

3 Comments

Ruby’s Object has a method, methods. You can use it to see the methods which an object has. Sort of. In this post I’m examining methods, public_methods, and private_methods as well as some of their implications.
Continue reading ‘methods, public_methods, and private_methods’

11Sep08 universal cat redux

programming refactoring ruby utilities

2 Comments

I have a neglectful relationship with inject. That is, I neglect to remember that it exists, having worked for so long with other languages which are “unfamiliar with the concept”. Amos King’s blog entry on Inject & Me – BFFs got me to thinking that ucat (see cat on steroids (or cat on a hot ruby roof)) could use inject as opposed to the each_byte. So, instead of

def non_printing(line)
  proc = ""
  line.each_byte do |c|
    proc += case c
      when (0 .. 8): "^#{(c + 64).chr}"
      when (10 .. 11): "^#{(c + 64).chr}"
      when (13 .. 26): "^#{(c + 64).chr}"
      when (27 .. 31): "^#{%w([ \\ ] ^ _)[c - 27]}"
      when 127: "^?"
      when ((c &amp; 128) == 128): "M-0#{c.to_s(8)}"
      else c.chr
    end
  end
  proc
end

I can do:

def non_printing(line)
  line.split("").map{|c|c[0]}.inject("") do |s,c|
    s += case c
      when (0 .. 8): "^#{(c + 64).chr}"
      when (10 .. 11): "^#{(c + 64).chr}"
      when (13 .. 26): "^#{(c + 64).chr}"
      when (27 .. 31): "^#{%w([ \\ ] ^ _)[c - 27]}"
      when 127: "^?"
      when ((c &amp; 128) == 128): "M-0#{c.to_s(8)}"
      else c.chr
    end
  end
end

I still think there needs to be a better way — going from string to an array of strings mapped to an array of bytes so that I can process it via inject seems to be awkward. So, I do some searching and find Object#enum_for (let me plug gotAPI — it’s a great tool for searching a large number of API’s) and come up with:

  def non_printing(line)
    line.enum_for(:each_byte).inject("") do |s,c|
      s += case c
              when (0 .. 8): "^#{(c + 64).chr}"
              when (10 .. 11): "^#{(c + 64).chr}"
              when (13 .. 26): "^#{(c + 64).chr}"
              when (27 .. 31): "^#{%w([ \\ ] ^ _)[c - 27]}"
              when 127: "^?"
              when ((c &amp; 128) == 128): "M-0#{c.to_s(8)}"
              else c.chr
           end
    end
  end

That seems cleaner to me. One of the things I love about ruby is that there’s usually more way than one to do something. And it’s often quicker, like in Unix, to go with what you know rather than making it more elegant. However, I also like that it’s easy to write elegant code.

And elegant code is a thing of beauty.

You can download the updated version of ucat.rb (you may need to rename it to ucat.rb)

10Sep08 cat on steroids (or cat on a hot ruby roof)

programming ruby utilities

1 Comment

I got to thinking about SuperIO and how it could be used as a swiss army chainsaw to open files, whereever they might be on the net. From there, my fevered mind got to thinking about cat and how the two could be used together. That said, I present ucat — a universal cat, if you will, which does not need to be herded, but rather will do as you ask. It’s expecting to be able to find SuperIO, so you’ll need to make it available.

Continue reading ‘cat on steroids (or cat on a hot ruby roof)’

02Sep08 A language a year

philosophy programming

3 Comments

The Pragmatic Programmers have proposed that developers learn a language a year. I agree that it’s very important to keep abreast of changes in IT and that by learning new languages we can keep our minds sharp and bring new ways of doing things into old languages. However, I have to wonder if this learning a language gets in the way of knowing a language.

I’ve always been a generalist, when I was younger I wanted to be a renaissance man. But sometimes I think that getting caught up in being a generalist is as large a trap as specializing in one thing and not not being willing to learn anything else.

When I was 19, I taught C at a local community college’s Continuing Ed programme. I’d been asked to do so six weeks prior to teaching the course. I followed K&R, and I know I was able to get the gist across to my students. I’d learned C, but I didn’t know C. It took at least 6-12 months of programming C day-in, day out to know the language.

And then there’s unix. I recently celebrated my 20th aniversary of using it. I can claim to having learned it, even perhaps understanding it. But knowing? I’m still discovering new aspects of it.

I agree that it’s important to learn new things, but sometimes you need to just know a thing.

27Aug08 Programming philosophy in the oddest of places

philosophy programming

2 Comments

Today’s thought for the day from A Word A Day is:

Not being able to govern events, I govern myself.

-Michel de Montaigne, essayist (1533-1592)

This struck me as being very much the idea behind defensive programming. Because we don’t know what sort of events life will throw at a programme, we need for it to be robust and able to respond to most anything, barring, of course, Fear, Fire, and Foes.

So how do we go about doing so? For starters, there’s testing, whether BDD or TDD. Boundary conditions and fencepost errors frequently cause grief. And any time the programme interracts with the “outside” there’s room for error — whether it be bad data or an I/O error.

Assume Nothing! Trust no one! Paranoia is good! (in moderation)

26Aug08 Sometimes More is Just Enough

Just Enough Programming programming

0 Comments

In the quest for simplicity and maintainability, sometimes we need to add components. It seems counter intuitive, perhaps, but sometimes it’s true.

As an example, I once came across a project which had multiple queries, each of which contained over 40 lines of SQL code. I don’t know about you, but 40 lines of code for a single query smacks of being overly complex. The query was too long for the database to optimize and far too long for humans to maintain, let alone understand.

In this case, to “simplify”, the queries were perfect candidates for database views and stored procedures. Thus, by adding components to the architecture, we’ve actually made it simpler and easier to maintain.

26Aug08 Why my code is broken….. (break my code redux)

gotchas programming ruby

0 Comments

Yesterday, I posted an article entitled Break my code, please, wherein I posted a very fragile piece of code, with the challenge to find ways in which to break it.

What follows is a discussion of the code and why it is bad/fragile/easily broken…..

Continue reading ‘Why my code is broken….. (break my code redux)’

25Aug08 Break my code, please

gotchas programming ruby

1 Comment

There’s a number of things we can should take into account when writing code — boundary cases, etc., that can make or break a programme. Yes, testing is important, but I think that developing good defensive programming practices is even more important. That said; I present the following, fragile, code. Just about every line has a case where it can fail. Can you break my code? I’ll post some test cases which cause it to fail later.

And for those looking for the next installment of O_RLY?, it’s coming soon; I’ve been embroiled in a hideous move.

Continue reading ‘Break my code, please’

22Aug08 Ruby’s ObjectSpace: Subclasses

ruby

5 Comments

One of the (imho) lesser used pieces of the Ruby language is ObjectSpace. In this article I’ll show one of the things you can do with it — get all the subclasses of a class.
Continue reading ‘Ruby’s ObjectSpace: Subclasses’