Read the 2D : Green Shoes section. I’m honored. :) Watch a demo I executed his code on my Windows 7.

Let’s have fun with Shoes! :-D

The discussion starts here but continues on our Google Plus post!

The nice thing about UnetBootin is that it runs on Windows, Mac, and Linux. It gives you access to many different tools and operating systems that you can then simply install to a USB drive. It isn’t limited to operating systems, but also for recovery tools, administration tools, and other “live” CD’s.

The current ‘favorite’ distribution of Linux for an install is probably going to be Ubuntu, as it is highly documented, has a large user base, there are plenty of resources that are easily found on the web. It is available, of course, in the drop down list of UnetBootin as a ‘Live CD’ install, which means that you can install it to that USB thumbdrive that you have, you can test drive it, and if you like what you see, you can install it to your system. But you won’t be disappointed in it as a first install.

But I want to use the tools on my native system until I feel comfortable enough!

To get some of the tools that are available on Linux to your current system, you may want to install some software, such as LibreOffice which seems to be taking the place of OpenOffice as an ‘Installed by Default’ office suite for some distributions of Linux. The OpenOffice suite is also a good office suite of tools, though, and LibreOffice is a derivative of this project.

DSL - The small ‘Linux on a Stick’ distribution

Now, DSL may not be exactly for the person wanting to get started or seeing their very first Linux experiences, but it is good to have in your tool box. It will get you running and connected to the network on perhaps an older machine that you want to browse the internet on, or just play around with. It can do some serious things, but this is an article written for those that want to get familiar with Linux, so it has its place.

This gives you a very small Linux distribution with some basic software that lets you get familiar with the look and feel of a Linux environmnet. It is meant to be loaded from USB stick, for a temporarily booted environment, but with your standard useful tools, such as Internet browsers, ‘Office’ software, etc. It doesn’t have installed by default the common “Office Suite” software, but is a lightweight distribution. And those installations are available, so you can install them.

Congratulations on wanting to expand your Operating Sytem Experience

There are many reasons to use Linux. Linux is a workhorse operating system. It is free to install, free to use, has a very long history, has great people working on it, and is no longer for the technically elite. My children have used it from a very young age, and my mother started using it last year.

There are professional grade tools, and games available on it, and the available software will only grow. Much of the software available is free in various meanings of the word, including no monetary charge for use, even commercial use.

If you are just starting out using a Unix-like system, you could be up and running today. Of course, like any complex system, there is a learning curve, but you can start being productive with it quickly, and the good thing is it will open you up to a whole new world of computing.

So congratulations on being open to Open Source Computing!

References

• UnetBootin
• DSL - Damn Small Linux
• LibreOffice
• OpenOffice

The conversation starts here.

But it continues on our Google Plus post

The course starts on 5 April, 2013, and the first 15 students are getting a discount.

Check out the announcement and register today!

I’ll be there!

The discussion starts here, but continues on our Google Plus Post!

I realized that Methods are blocks and Procs and lambdas are very close, so was wondering if the arguments would cross over.

It turns out that it does.

If you are not familiar with the new “named parameters” feature, it works by taking a Hash argument, along with another new syntax that starts with a two asterisks. Similar to the “optional argument” syntax, it basically accepts all other non-named hash keys that you would give your method. Or, Proc or lambda.

Let’s look at the signature:

1

def some_method(*args, name: 'Joe', age: 23, **additional_params)

This describes an argument list consisting of an 0 or more arguments for *args, a named parameter called name, with the value of ‘Joe’ by default, and a named parameter of age, with a default value of 23, and at the end, the syntax that allows you to pass in arbitrary number of hash keys, with values.

It is important to note that in order to have the **additional_params at the end, after the normal Hash that you may be used it, you must use the Ruby 1.9 syntax of key: value, rather than :key => valueor it will break.

Well, that is wonderful, as it means that we no longer need to do the hash merge to bring in default ‘params’.

But you will have likely read about that elsewhere.

The thing that I was happy to discover was the “named params” are available for Proc and lambda.

This means that we can now do something like this:

1
2
3

my_proc = Proc.new do |name: 'Joe', age: 23, **other_params|
  [name, age, other_params]
end

If you were to pass nothing at all to the Proc, you would get this: ["Joe", 23, {}]

Let’s see what happens if you change the name, and give it a some undetermined parameter:

1
2
3
4
5

my_proc = Proc.new do |name: 'Joe', age: 42, **other_params|
  [name, age, other_params]
end

my_proc[age: 49, hobbies: ['long walks', 'candlelight dinners', 'romantic comedies']]

We would end up with this as a return:

["Joe", 49, {:hobbies=>["long walks", "candlelight dinners", "romantic comedies"]}]

Compared to the extra work we would have had to do to get this in Ruby 1.9, I like it.

Did you know that the conversation starts here, but continues on in our Google Plus+ Post?

I am usually in VIM for my editor. Not the graphical (gvim) version, the one that runs in the terminal.

I also use Carlhuda’s Janus configuration.

But there are things that I change that are simply minor things.

To do this, according to the documentation for customization, I use ~/.vimrc.after and here are my settings.

These are miscelanious things that I wanted to have. The relativenumber setting seems to not be as persistent as I would like though.

1
2
3
4
5
6
7
8
9
10
11
12
13

set t_Co=256
set showcmd
set foldmethod=syntax
set wildmenu
set wildmode=list:longest
set virtualedit=all
set visualbell
set relativenumber
set wrap
set linebreak
set nolist
set textwidth=0
set wrapmargin=0

An abbreviation that I use pretty often.

1
2
3

" rdt<space> does an autocompletion which gives me a rubydoctest
" comment block
iab rdt =begin<CR>doctest: <CR>>> <CR>=> <CR>=end<CR><Up><Up><Up>

This next line clears the highlights that happen when you search. For me, my leader is ,.

1

nnoremap <leader><space> :noh<cr>

Add this in here if you really want to be enforced not to use the arrow keys. Enable it for a few days and pretty soon you just don’t reach for the arrow keys until you really need them.

1
2
3
4
5
6
7
8

nnoremap <up> <nop>
nnoremap <down> <nop>
nnoremap <left> <nop>
nnoremap <right> <nop>
inoremap <up> <nop>
inoremap <down> <nop>
inoremap <left> <nop>
inoremap <right> <nop>

Well, there you have it. Most of my configuration file that I have in addtion to the Janus configuration.

What things do you have in your configuration that you really like to have? I am sure it is more exciting than mine!

The discussion starts here, but continues on this Google+ Post!

Watch a little demo.

Cool! Enjoy with your kids!
ashbb

The discussion starts here, but continues on our Google+ post!

This is part of the code that I use through inspiration from the Ruby Spec project. I haven’t checked the code, so I don’t believe it is identical in functionality.

The helper.rb file is loaded with my helper file in my testing folder.

1
2
3
4
5

def ruby_version_is(version_string)
  if version_string == RUBY_VERSION
    block_given? ? yield : true
  end
end

This allows me to do the identical thing you saw on line 63 of that link above. In other words, I can use it with a block and it just does the right thing.

Or I can use it like a query, and it will either return true or nil.

This makes it simple for me to have tests that are version specific, yet won’t fill my tests with failures just because of a version difference.

It also lets me search for those things that are specific to a version.

Ruby 2.0.0-p0 is out, and I used it to document the new to_h functionality

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

require 'spec_helper'

Car = Struct.new(:make, :model, :year) do
  def build
  end
end

ruby_version_is '2.0.0' do
  describe 'Ruby 2.0.0 stuff' do

    before :each do
      @car = Car.new('Toyota', 'Prius', 2014)
    end

    it 'converts class to hash' do
      @car.to_h.must_equal make: 'Toyota', model: 'Prius', year: 2014
    end

  end

end

Now I can run this test alongside others, and I don’t have to worry about what version of Ruby it is testing against.

I think that I will add some functionality though. So I can specify a minimum version of Ruby, and when 3.0.0 comes out, I will know what things change based on the tests, because they will run against that version as well, while not running against previous ones.

Anyway, how do you test against different versions of Ruby?

Continue this conversation on our Google Plus post!

I wanted to apply my “Learn By Testing” repository on this new Ruby, and am running into a few problems. The first was Bundler 1.3.0 needs to be installed. Simple enough to install. Just go to the repository, clone it, select the tagged version, then install it locally as a gem.

Trying to use a Gemfile with Bundler though is giving me some errors.

See, I am using Guard and I wanted to add the rb-inotify gem to my Gemfile. But in doing so, I get this error:

1
2
3
4
5

~/.rvm/gems/ruby-2.0.0-p0/gems/bundler-1.3.0.pre.8/lib/bundler/lazy_specification.rb:74:in `method_missing': LazySpecification has not been materialized yet (calling :required_ruby_version []) (RuntimeError)
        from ~/.rvm/gems/ruby-2.0.0-p0/gems/bundler-1.3.0.pre.8/lib/bundler/match_platform.rb:11:in `match_platform'
        …
        from ~/.rvm/gems/ruby-2.0.0-p0/bin/ruby_noexec_wrapper:14:in `eval'
        from ~/.rvm/gems/ruby-2.0.0-p0/bin/ruby_noexec_wrapper:14:in `<main>'

The problem is that in my RVM I had a bundler 1.2 version installed in the @global gemset.

Removing the global bundler, making sure that Bundler 1.3.0 was installed, seems to have corrected the issues.

Now on to write tests for Ruby 2.0 and absorb some knowledge while recording what I have learned.

A hands on guide for Ruby newbies to create and publish their first Ruby gem.

Satish has published a booklet that takes you through the steps required to publish your first Ruby Gem. Recently updated with information on how to ‘yank’ your gem in case you don’t need it to be available, it is a good short reference to get you quickly started in the world of Ruby Gems.

There are tools out there that do the work for you in terms of having a skeleton. This booklet will cover none of those. It will take you through the basics to get a gem up and running in a few short minutes.

Yes, all the information is available for free. And it is not that difficult to find it all. But dropping a dollar to have a handy reference on your Kindle to support Satish’s efforts on RubyLearning is just a small way to say “Thanks!” and a way to show some love.

Co-founder Garry Tan is providing this solution for US $5.00 per month as per his tweet. Not a bad idea.

Posterous Will Shut Down On April 30th, Co-Founder Garry Tan Launches Posthaven To Save Your Sites

It was a great thing for us. It was great while it lasted, and we definitely emjoyed the ease to involve the people that wanted to write but didn’t want to necessarily have their own blog set up. E-mail to our blog address, and it was as simple as that. It even let my children post via e-mail from their e-mail or even from their phones for the photos that they took occasionally. A great idea for that kind of thing, easier privacy settings for the kids than Facebook without all the intricate settings, and just simple to use.

For us, for right now, it looks like it is Github and Octopress. This should work very well for a technical blog, it should let us express the things that we would like to express, and it will allow simple team management for those that have experience with git and markdown.

It won’t be as simple in a lot of ways as Posterous was. But it will afford us some more features and the fun of learning and playing with a new system. Plus, it is fully customizable, still without the overhead you get with hosting your own servers, etc.

We will miss Posterous! But we are excited about moving on and learning new things.

I’d like to introduce joonty’s fantastic project on github.

Read this post: New gem: breaktime

Cool! Try it out! :-D

–ashbb

Watch a demo.

Have fun with Shoes,

ashbb

The discussion starts here, but continues on at our Google Plus Post!

First I started with an install from turnkey, so that I could look over a well thought out install. And it was pretty simple aside from one timeout issue. Easilly fixed once I looked through the configuration files. It was running vesion 2.5.0, you can download a virtual machine install from www.turnkeylinux.org, search for gitlab,

I then blew away the VM and installed it again and made some changes that I wanted to see, just to get a feel for how I could manipulate things and break them.

Finally, the last time (and this screenshot) is from an install right from the gitlab instructions. It was very straight forward, I did find one error in /home/git/.gitolite.rc which had a single quote in the wrong place, I replaced it with a slash to give it a glob pattern. (I think it was the right thing to do). If you are curious, it is on line 22.

This is version 3.0.3 and pulled down from the stable branch.

From playing with it a little bit (and I found out from pushing the gitlab stable branch only) that gitlab expects and requires a master branch to be created and pushed up, otherwise it doesn’t know to display even the only branch that is there. So that took me a moment to realize.

Remove the master branch, and you will go back to the instruction page directing you to do a git config –global username and mail standard things for git configuration as it pertains to your settings.

If you are wanting to play with the demo, you can from the link above… or if you would like to play with it with your own account, you can right at gitlab.com (I don’t know why that domain isn’t in your face when you go to their main web page.) They are running, as of this post, version 2.9.1.

If you decide to install it or use it in the various ways that you are able to, let me know your results, how you are using it, and what you think about it. Have you customized it? Added a registration page, etc.?

I got the opportunity to review Exploring Everyday Things with R and Ruby by Sau Sheong Chang and published by O’Reilly Media.1  

This book, as expected, talks about R and Ruby.  The first chapters cover Ruby at an introductory level.

In the first chapter, after showing how you can install Ruby and an introduction to the basics of Ruby, he also provides a quick introduction to Shoes, a simple but powerful UI toolkit for Ruby2, with installation suggestions and sample code.

His introduction to Ruby covers the basics and is just a little bit more than enough to understand the code in the rest of his book.  I think he did a really good job of that.  The second part of the first chapter, covering Shoes, explains Shoes in a nutshell rather well, I think.  You will get to use Shoes in later chapters.

He then goes on to introduce R, which I had not used before.  He covers in a way that was fairly straightforward to install and get running.  Within a few moments, I had R installed and the ‘normal’ graphical tools up and running and was able to run some sample code, and even had graphs floating around my screen based on data that I created from the samples.

Shortly after that, I had R code being created in my favorite text editor, and executing code right from there.

His introduction to the language is fairly quick, but again, just a bit more than enough to get you going.

He also covers some statistical transformation examples to change the statistical data into plottable information.  That is a good thing, because throughout the book, you will be needing to recognize this in the examples, and will have fun producing your own graphical representations of data you get.

And all that is enough to get you started creating models to solve real world problems.

For example, do you need to convince your boss that you need more restrooms available for the people in your office?  You can provide some simulations and reports and graphs (the boss likes graphs, right?) to support your argument, or will it support his assertion that what you have is just the right amount?

This gets to the fun part.  Have you ever wondered how to mine data from your own e-mail?  To find trends of when you send mail, or who you communicate with most?   Finding the most frequently used words and the trending themes in your communications?   You are in luck.  He will take you through the Enron Saga to lightly touch on analyzing that e-mail data 3, but easily apply it to your own IMAP e-mail accounts.

How about biometrics, recording your own heartbeat through a home made electronic stethoscope?  Yes, you will be able to do this, and take measurements, and analyze them graphically.  Combine that with pulse oximetry with your webcam and you might have just enough evidence to convince your boss that your cubicle is suffocating you.

That sounds fun enough, but it will involve analyzing sound files and video files to get the readings and measurements that you want to produce in a graphical chart.   That makes it fun to the nth power, right?

Well, what can be more fun than Boid’s… and boid is the woid in this next chapter.   Using Ruby Shoes you will explore the flocking of birds, you will write a simulation and are encouraged to continue playing on.

What follows is an extension of the Boids and introduces the mortality and procreation of the boids, which were prior to this immortals in a veritable utopia.  Life simulated and analyzed.

Overall, I really enjoyed this book, it was easy to read, had some math in it, of course, but nothing that requires advanced math.  And the topics were fun to work through.  And there is plenty of room to experiment and explore after finishing the chapters.

Note; This review cross posted at RubyLearnings Blog with permission.

The conversation starts here, and continues on Google Plus!

Currently the list shows:

I placed this in my ~/bin folder so that I could run it whenever I need a quick refresher on the available assertions. It will automatically include changes as minitest gets updated over time and versions.

My way of programming the computer systems have been normal, albeit slower than the technology has evolved, I began by imperative programming applications in command line mode and have I kept more within the server components of the solutions that have developed or maintained.

However, every time I make a foray into programming mode applications GUI it always suffers from too much friction and impedance. And even when you reach the end, most often it does not end up being what you expected from the beginning.

Leaving aside the issues connected with NPP - Non-Programmers Programming - and with the usual challenges around the lineup - Software Craftsmanship - This article addresses two issues: why is it difficult for programmers to encode good user interfaces and a possible answer to minimize this impedance ( Paper Prototyping ).

Firstly, I have learned that 80% (or more) of the value of an application is evaluated by the user on the user interface of this application.

Jeff Atwood in his article “The User Interface Is The Application”, says that no matter how spectacular the architecture diagrams are that exist for an application, with respect to the user of that application, the user interface is the application. It is true that the task of building a good user interface is difficult but to be taken seriously you have to go beyond and build an impressive user interface.

And he even cites Yukihiro Matsumoto, creator of the Ruby language:

If you have a good interface on your system, and the budget of money and time, you can work on your system. If your system has bugs or is too slow, you can improve it. But if your system has a bad interface, you have basically nothing. It will not matter if it is the work of the highest craftsmanship on the inside. If your system has a bad interface, no one will use it. So the interface or surface of the system, whether to users or other machines, is very important.

The assumption that building a good user interface is difficult, is it reasonable to expect that any programmer with no training or experience in UI Design can build and maintain a good user interface?

Some responses also came from another article from Jeff Atwood, “UI is Hard”, where he writes that in part are the developers themselves primarily to blame because - like me - most programmers begin to think in code and business logic rather than begin by thinking about the user interface. And that majority is represented in part on your comments to this article.

Other responses came from other similar articles, “UI Design” blog “Buggin’ My Life Away” by Rick Schaut and “Can Programmers Do Interaction Design?” by Kim Goodwin of Cooper in the Journal.

What is Rick points out that when working on software for the user it doesn’t matter if it is a web application or desktop, or add new features, the focus is in designing the user interface - first and foremost. And this is complicated because programmers are first used to implement efficient algorithms for common problems in computer science but not learned or have enough experience on how to design a good user interface. Secondly, most of the tools facilitates the rapid creation of user interfaces for most simple problems of usability , but they tend to fall short of what is needed also to facilitate the rapid creation of interfaces for a set of usage scenarios that are more complex.

In another interesting article, “The Rise and Fall of Homo Logicus” by Jeff Atwood quotes an excerpt from the book The Inmates Are Running the Asylum by Alan Cooper: There is a large impedance for a programmer to design an interface for the user. Because while most developers have a more forward-thinking knowledge about how everything works, most users have only a thought turned to the success of a task. He ends the article saying that we must stop thinking like Homo Logicus and think more like Homo Sapiens.

The article by Kim said that instead of resulting in the lowest cost having the programmers design the user interface it has been the opposite: it is more inefficient, more costly and more likely to be a failure. And the failures is that it results in more programming, right?

So how to avoid the impedance between what the programmer is able to create and what the user is typically waiting for?

First, many articles recommend to start the development by creating the user interface even to the point (extreme and ironic) to appoint a methodology to be followed: FAD.

Secondly, the use of paper prototyping - what other benefits avoids many of the pitfalls in prototyping applications - due to better mitigate the risks normally inherent in having the feedback of the users only after laborious programming tasks

• Posted in: doCoding
• Author: José Carlos Monteiro

• const_missing
• included
• extended
• inherited
• method_missing
• method_added
• singleton_added
• method_removed
• method_undefined

The discussion starts here, but continues on our Google+ post!

The ternary operator is not reasonable for a situation that returns true or false; if the goal is to get a result of true or false from your decision, it is better to simply evaluate the statement itself.

For example, if it reduces to this statement:

1

some_condition ? true : false

then you are better off just simply using some_condition by itself, as it will evaluate to either true or false.

If, however, you have a statement that evaluates such as

1

some_condition ? true : (some_action or other value)

What you may be asking for and really wanting is the OR Operator, rather than the ternary:

1

some_condition || do_this_if_"some_statement"_evaluates_as_false

If this doesn’t immediately look familiar, look at this:

1

assign_this = evaluated_condition ? true : expression_if_evaluated_statement_is_false

Is the same as:

1

assign_this = evaluated_statement_if_true or expression_if_evaluated_statement_is_false

On the other side of the spectrum, when you have

1

some_statement ? (some_action or other value) : false # or nil

You will want to use the AND operator:

1

some_condition && do_this_if_some_condition_evaluates_as_true

Rather than using the ternary with a false return like:

1

assign_this = evaluated_condition ?  (some_action or other value)  : false

Remember, the point of either is having an evaluated statement that has the possibility of being false (or nil) as well as the possibility of being true.

If your evaluated statement never has both possibilities, then these aren’t the operators for you at this moment.

In conclusion, we use the ternary operator when we have a simple if..then operation that does not return either true or false itself. We use the or and and operator when we need one evaluation or the other. When using the ternary operator, we don’t use it to return true or false, there are easier ways to do that.

The discussion starts here, but continues in our Google Plus Post!

The statement that we always say when talking about chomp and to_i or to_f is that to_i and to_f does the same thing as chomp, and this is almost true. But to_i and to_f actually work more like strip.

Consider this:

1
2
3
4
5
6

>> gets.strip
   98
=> "98"
>> gets.to_i
   98
=> 98

As you can see, in reality to_i strips the leading whitespace, and by definition any trailing whitespace (though in reality all string content that isn’t part of the first recognizable ‘numeric-like’ string) including the record separator.

So, I am trading in my habitual String#chomp use for the cleaner String#strip use, and where appropriate String#strip! and I believe I will still have fun with Ruby!

Let me know what you think about this small movement?

Sample 64 is one way to swap the layers between them. :)

Ashbb