| Topic | Processing: Cool Graphics Now |
| Speaker | Matt Secoske |
| Time | December 4, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
| Language | Avg Methods/Class | Max Methods/Class | Avg Params/Method | Max Params/Method | Avg Fields/Class | Max Fields/Class |
| Squeak | 9.39 | 780 | 0.64 | 16 | 1.02 | 100 |
| Ruby | 12.69 | 683 | 0.42 | 7 | 0.76 | 31 |
| Java | 8.67 | 181 | 0.91 | 12 | 2.42 | 343 |
world: aMorph
world == aMorph ifTrue: [^ self].
world ifNotNil: [world removeActionsWithReceiver: self].
world := aMorph.
world ifNotNil:
[self changeTextOnTab.
world
when: #aboutToLeaveWorld
send: #leavingWorld
to: self]
changeTextOnTab
self monticelloFlapTab ifNotNilDo: [:tab | tab changeTabText: Project current name]
monticelloFlapTab
^Flaps globalFlapTab: 'Monticello'
leavingWorld
WorldState addDeferredUIMessage: [self world: Project current world]
addMonticelloFlap
| newTab monticelloBrowser |
newTab := Flaps newFlapTitled: 'Monticello' onEdge: #bottom.
self currentWorld addMorphFront: newTab.
newTab adaptToWorld: self currentWorld.
Flaps addGlobalFlap: newTab.
newTab showFlap.
monticelloBrowser := MCWorkingCopyBrowser new.
(monticelloBrowser window)
openInWorld: newTab referent extent: monticelloBrowser defaultExtent;
topLeft: newTab referent topLeft + (10 @ 10).
newTab referent height: monticelloBrowser window height + 20.
newTab hideFlap
| Topic | PHP: Practical Web Programming |
| Speaker | Ben Heath |
| Time | November 6, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
But I wonder if all open-source projects will eventually go the way of all software. Upgrade after upgrade adds more and more complexity, to the point where the software begins to get bogged down under its own weight. How many open-source projects have you seen in which the code gets leaner and meaner rather than fatter and fatter?
Just look at Firefox, one of the poster children for open source. It loads more slowly than ever. It will be on some page within a tab, and that page will be refreshing ads or something in the background, and Firefox just hangs all its cycles there, slowing down the whole computer. Every couple of days the browser is hogging cycles, and I have to go to the Task Manager and kill it. Other people have this problem, too.
| Topic | A Gentle Introduction to Erlang |
| Speaker | Sam Tesla |
| Time | October 2, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
class Comparator
def initialize(&default)
if (defined? default)
@compare_block=default
else
@compare_block=lambda { |a,b| a <=> b }
end
end
def compare(a,b)
@compare_block.call(a,b)
end
def to_proc
method(:compare).to_proc
end
def to_comparator
self
end
def then_by(next_aspect)
next_comparator=next_aspect.to_comparator
self.class.new do |a,b|
comparison=compare(a,b)
if (comparison == 0)
next_comparator.compare(a,b)
else
comparison
end
end
end
def reverse
self.class.new do |a,b|
comparison=compare(a,b)
if (comparison == 1)
-1
elsif (comparison == -1)
1
else
0
end
end
end
end
def by(aspect_to_compare)
aspect_to_compare.to_comparator
end
class Symbol
def to_comparator
Comparator.new { |a,b| a.send(self) <=> b.send(self) }
end
end
module Enumerable
def to_comparator
inject do |thus_far, every|
thus_far.to_comparator.then_by(every.to_comparator)
end
end
end
require 'rubyunit'
class SortTest < Test::Unit::TestCase
def test_simple
a=Person.new("blaine", 36)
b=Person.new("blaine", 12)
result=[a,b].sort(&by(:name).then_by(:age))
assert_equal([b,a], result)
end
def test_array
a=Person.new("blaine", 12)
b=Person.new("alice", 12)
result=[a,b].sort(&by([:age, :name]))
assert_equal([b,a], result)
end
def test_reverse
a=Person.new("grue", 123)
b=Person.new("thief", 34)
result=[a,b].sort(&by(:name).reverse)
assert_equal([b,a], result)
result=[a,b].sort(&by(:age).reverse)
assert_equal([a,b], result)
end
end
class Person
attr_reader :name, :age
def initialize(name, age)
@name=name
@age=age
end
end
[1,2,3,4].inject() {|a,b| a + b} # 10
------------------------------------------------------ Enumerable#inject
enum.inject(initial) {| memo, obj | block } => obj
enum.inject {| memo, obj | block } => obj
------------------------------------------------------------------------
Combines the elements of _enum_ by applying the block to an
accumulator value (_memo_) and each element in turn. At each step,
_memo_ is set to the value returned by the block. The first form
lets you supply an initial value for _memo_. The second form uses
the first element of the collection as a the initial value (and
skips that element while iterating).
# Sum some numbers
(5..10).inject {|sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).inject(1) {|product, n| product * n } #=> 151200
javascript:void(0)
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo,word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
# find the length of the longest word
longest = %w{ cat sheep bear }.inject(0) do |memo,word|
memo >= word.length ? memo : word.length
end
longest #=> 5
class Symbol
def to_proc
lambda do |this, *arguments|
this.send(*arguments)
end
end
end
def pair(left,right)
lambda do |dyadic|
dyadic.call(left,right)
end
end
def left(pair)
pair.call(lambda {|left,right| left})
end
def right(pair)
pair.call(lambda {|left,right| right})
end
require 'rubyunit'
class WorkspaceTest < Test::Unit::TestCase
def test_simple
a_b=pair('a','b')
assert_equal('a',left(a_b))
assert_equal('b',right(a_b))
end
def test_again
a_b=pair('a', 'b')
c_a_b=pair('c', a_b)
assert_equal('c', left(c_a_b))
assert_equal('a', left(right(c_a_b)))
end
end
module Enumerable
def reduce(empty_return=nil, &dyadic)
to_execute=lambda do |thus_far,every|
to_execute=dyadic
every
end
inject(empty_return) do |thus_far, every|
to_execute.call(thus_far,every)
end
end
end
require 'rubyunit'
class ReduceTest < Test::Unit::TestCase
def test_simple
result=[1,2,3,4,5].reduce {|thus_far,every| thus_far + every}
assert_equal(15, result)
end
def test_empty_nil
result=[].reduce {|result,every| thus_far + every}
assert_nil(result)
end
def test_empty_default
result=[].reduce(0) {|result,every| thus_far + every}
assert_equal(0, result)
end
end
class Symbol
def to_proc
lambda do |*arguments|
arguments.shift.send(self, *arguments)
end
end
end
class SymbolTest < Test::Unit::TestCase
def test_simple
result=[1,2,3,4,5].reduce &:+
assert_equal(15, result)
end
end
the Smalltalk version is a great example of accidental complexity, not essential complexity.
class Person
attr_accessor :name
end
attributeAccessors
^#(name)
Object subclass: #Person
attributeAccessors: 'names'
classVariables: ''
poolDictionaries: ''
category: 'MetaExample'
initialize
self attributeAccessors: 'name'
Smalltalk had (and has) an awesome environment, including incredible tool support. Because the tool is pervasive (literally part of the project itself), Smalltalkers generally shied away from the kind of meta-programming described above because you have to build tool support along with the meta-programmed code. This is a conscious trade off. One of the best things about the Ruby world (up until now) is the lack of tool support, meaning that the tools never constrained (either literally or influentially) what you can do. Fortunately, this level of power in Ruby is pretty ingrained (look at Rails for lots of examples), so even when the tools finally come out, they need to support the incredible things you can do in Ruby.
One of the best things about the Ruby world (up until now) is the lack of tool support
| Topic | Rexx: The Little Known Scripting Language |
| Speaker | Scott Hickey |
| Time | September 4, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
def test_independence
first = "3" + "4"
second = first + "5"
third = "2" + second
assert_equal("34", first.to_s)
assert_equal("345", second.to_s)
assert_equal("2345", third.to_s)
end
class DelayString
def initialize(oneString, anotherString)
@left = oneString
@right = anotherString
end
def +(another)
DelayString.new(self, another)
end
def to_s()
return @result unless @result.nil?
to_process=[self]
@result=String.stream_contents do |out|
until (to_process.empty?)
current=to_process.pop
current.process(to_process,out)
end
end
end
def process(to_process,io)
to_process.push(@right)
to_process.push(@left)
end
end
class String
def self.stream_contents(&monadic)
StringIO.open() do |io|
monadic.call(io)
io.string
end
end
def +(another)
DelayString.new(self, another)
end
def process(to_process,io)
io << self
end
end
require 'rubyunit'
class Promise
def initialize(&block)
@calculation=block
@value=nil
end
def value
return @value if @calculation.nil?
@value=@calculation.call()
@calculation=nil
freeze()
return @value
end
def value?
@calculation.nil?
end
end
def promise(&block)
Promise.new(&block)
end
class PromiseTest < Test::Unit::TestCase
def test_simple
promise = promise { 3 + 4 }
assert(!promise.value?)
assert(7 == promise.value)
assert(promise.value)
end
end
require 'stringio'
class DelayString
def initialize(oneString, anotherString)
@strings = [oneString, anotherString]
@promise = promise do
stream = @strings.inject(StringIO.new) do |output,each|
output << each
end
@strings = nil
freeze()
stream.rewind
stream.read
end
end
def +(another)
return another.concatBeforeDelayString(self)
end
def concatBeforeString(another)
@strings.unshift(another)
self
end
def concatAfterString(another)
@strings.push(another)
self
end
def concatBeforeDelayString(another)
strings_each do |each|
another.concatAfterString(each)
end
another
end
def concatAfterDelayString(another)
another.concatBeforeDelayString(self)
end
def to_s()
@promise.value()
end
private
def strings_each(&block)
@strings.each(&block)
end
end
class String
def +(another)
return another.concatBeforeString(self)
end
def concatBeforeString(another)
another.concatAfterString(self)
end
def concatAfterString(another)
DelayString.new(self, another)
end
def concatBeforeDelayString(another)
another.concatAfterString(self)
end
def concatAfterDelayString(another)
another.concatBeforeString(self)
end
end
class DelayStringTest < Test::Unit::TestCase
def test_simple
add = "3" + "4"
assert_equal("34", add.to_s)
end
def test_string
add = "3" + "4"
add = "2" + add
add = add + "5"
assert_equal("2345", add.to_s)
end
def test_delay
add_before = "1" + "2"
add_after = "3" + "4"
add = add_before + add_after
assert_equal("1234", add.to_s)
#make sure to get same answer twice
assert_equal("1234", add.to_s)
end
end
def test_performance
add = ''
1000000.times do |iteration|
add = add + 'a'
end
add.to_s
end
# def +(another)
# return another.concatBeforeString(self)
# end
| Topic | Bioinformatics and Perl |
| Speaker | Jay Hannah |
| Time | July 10, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
I complete agree with you Blaine about not throwing away information. Keep everything, and add to that information whenever you have something to add. For example, when a caller catches an exception, the caller always has some indisputable and unique information it can add: exactly what it was trying to attempt when the failure happened.
Dropping this information is like using a shredder. It's not responsible behaviour for developers to shred information that might be useful to the poor sod who had to fix your buggy code at 4am in a production environment.
Actually, such information is often the 'single golden clue' that leads to a rapid diagnosis of the error. For this reason, I believe it's justified to add such information even when unchecked exceptions occur. "Yes, you got a NullPointerException, but what exactly were you trying to do when you caught the NullPointerException?"
For that reason only, I disagree with you about catching only the most specific exception- I always catch, wrap and rethrow any subclass of java.lang.Exception. I started handling exceptions in Java this way back in 1997, and haven't seen anything since that has caused me to change my mind (but I'm open to debate).
I think that we a few more people with that T.H.O. attitude to prevent open-source libraries from stagnating. It is a good thing that the incumbent 'standard' library gets regularly challenged by contenders. Without continual selection and reselection, evolution dies and progress stops.
The argument that we only need just one of anything is really unhealthy. It leads to mediocrity: I present J2EE as a perfect example. One of everything you could possibly want, put it all together and what do you have? Crap.
try {
...hard stuff here...
} catch(Exception problem) {
problem.printStackTrace();
}try {
...something hard here...
} catch(Exception ex) {
throws new RuntimeException("Something bad happened");
}| Topic | Cold Fusion |
| Speaker | Ryan Stille |
| Time | June 5, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
if (transaction.amount) {
transaction.markValid();
} else {
transaction.markInvalid();
}
if (transaction.amount == undefined) {
transaction.markValid();
} else {
transaction.markInvalid();
}
Can you give a more specific example please? I don't see anything wrong with this, for instance,
| file |
file := self loadPaymentFile: self sample.
self assert: file validPayments size = 3.
self assert: file invalidPayments size = 1.
| Topic | GData |
| Speaker | Brent Adkisson |
| Time | May 1, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
| Topic | Flex/ActionScript |
| Speaker | Axel Jensen |
| Time | April 3, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
| Topic | Domain Specific Languages |
| Speaker | Matt Secoske |
| Time | March 6, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
Posts
