carriagereturn.org

polymorphism

Fri, 10 Feb 2012 04:10:07 -0000

Methods / Functions of polymorphic type (that can take many different types) are said to be polymorphic

The opposite of polymorhpic is monomorphic. A monomorphic function is for example: thisFunc(int, int)

All methods that take an object are polymorphic, because the object given could be a subclass of the declared object, and this will only be known at runtime.

polymorphism glossary

Thu, 09 Feb 2012 04:10:04 -0000

---+ Polymorphism

---++ From the dictionary
polymorphism

A concept first identified by
Christopher Strachey (1967) and developed by Hindley and
Milner, allowing types such as list of anything. E.g. in
Haskell:

length :: [a] -> Int

is a function which operates on a list of objects of any type,
a (a is a type variable). This is known as parametric
polymorphism. Polymorphic typing allows strong type checking
as well as generic functions. ML in 1976 was the first
language with polymorphic typing.

Ad-hoc polymorphism (better described as overloading) is the
ability to use the same syntax for objects of different types,
e.g. "+" for addition of reals and integers or "-" for unary
negation or diadic subtraction. Parametric polymorphism
allows the same object code for a function to handle arguments
of many types but overloading only reuses syntax and requires
different code to handle different types.

See also generic type variable.

In object-oriented programming, the term is used to describe
a variable that may refer to objects whose class is not
known at compile time and which respond at run time
according to the actual class of the object to which they
refer.

testing helper

Wed, 08 Feb 2012 04:10:08 -0000

*Generator*

Generator --> Component

Creates test data and feeds it into the component under test. Test data can be read from a script file that contains instructions on the test execution as well as test data. Or test data can come from a capture / replay mechanism which captures data output by an external application or another test case and stores it for replay. Or test data can be created randomly or algorithmically.

*Verifier*

Component --> Verifier

A Verifier compares actual test results with expected results. Usually tied into a reporting mechanism.

*Stub*

Component <--> Stub

Simulates part of the system under test.

complexity

Tue, 07 Feb 2012 04:10:02 -0000

Two weapons against complextiy:

- Intuitiveness of the programming experience from the developers point of view.
- Ability to decompose the whole into smaller units and aggregate individual units into a whole.

apology

Mon, 06 Feb 2012 04:10:05 -0000

In the past few days spammers seem to of discovered the 'submit' link on carriagereturn.org. This morning a spam made it past me and got mailed / RSSed out to you all. My apologies. I have disabled the 'submit' link for the time being.

When I have some time I intend to restore the submit link with a spam-proof addition: Kitten Auth http://www.thepcspy.com/kittenauth

- Graham

reading complexity

Fri, 03 Feb 2012 04:10:05 -0000

Read better:

SQ3R technique:
* Survey:
Survey the document: scan the contents, introduction, chapter introductions and chapter summaries to pick up a shallow overview of the text. Form an opinion of whether it will be of any help. If it does not give you the information you want, discard it.
* Question:
Make a note of any questions on the subject that come to mind, or particularly interest you following your survey. Perhaps scan the document again to see if any stand out. These questions can be considered almost as study goals - understanding the answers can help you to structure the information in your own mind.
* Read:
Now read the document. Read through useful sections in detail, taking care to understand all the points that are relevant. In the case of some texts this reading may be very slow. This will particularly be the case if there is a lot of dense and complicated information. While you are reading, it can help to take notes in Concept Map format.
* Recall:
Once you have read appropriate sections of the document, run through it in your mind several times. Isolate the core facts or the essential processes behind the subject, and then see how other information fits around them.
* Review:
Once you have run through the exercise of recalling the information, you can move on to the stage of reviewing it. This review can be by rereading the document, by expanding your notes, or by discussing the material with colleagues. A particularly effective method of reviewing information is to have to teach it to someone else!

singleton pattern

Thu, 02 Feb 2012 04:10:05 -0000

Singleton Pattern

The Singleton pattern is used when you only need one of a particular object. For example a printer manager object, a database connection pool, etc.

This is achieved by giving the class a private class level method of type itself, making the constructor private, and giving it a class level getInstance() method which returns the only copy of itself.

Singleton's are considered harmful by many these days because they are object-oriented global variables. And we _know_ those are bad.

Design UI Spacing

Wed, 01 Feb 2012 04:10:02 -0000

One of the telling differences between an application design that is handled by a designer and one that is handled more by a development team is spacing. Developers don't usually think much about how element should sit on a screen together, so you see a lot of items crammed together or unevenly distributed. This is the kind of thing an average user can't put their finger on, but on a subconscious level, it bothers them and gives them a negative opinion of the application.

adapter pattern

Tue, 31 Jan 2012 04:10:07 -0000

When inserting an abstract interface is infeasible because the target is third party software then insert your own interface / class between you and the software and make all interactions with it use that.

The inserted interface / class is an Adapter.

writing

Mon, 30 Jan 2012 04:10:07 -0000

Writing well:

- Speak what you write: Read it out loud to see if it is easy to read.
- Punctuate. Check spelling and grammar.
- Keep sentences short.
- Don't use words you don't really know
- Front load your point: Don't make people wade through anecdotes to get to the point.
- When in doubt, simplify. Simpler is easier to understand, hence is more effective communication.

(from http://www.scalzi.com/whatever/004023.html)

environment smells

Fri, 27 Jan 2012 04:10:10 -0000

Development environment smells:

- No command line build. This is pure evil. No excuses, ever.
- Build environment tied to a particular IDE. I can't believe that people do this. But they do, sigh.
- No specific development test environment. You need to practice deployment
- Development environment depends on externally managed resources. Database goes down, team stops work. Dumb.
- A development environment that mandates a "reusable framework". Reuse is dead. Build a bridge, get over it.

Expression builder

Thu, 26 Jan 2012 04:10:07 -0000

One of the problems with a FluentInterface is that it results in some odd looking methods. Consider this example:

customer.newOrder()
.with(6, "TAL")
.with(5, "HPK").skippable()
.with(3, "LGV")
.priorityRush();

Methods like with, skippable, and priorityRush don't sit well on the Order class. The naming works well in the context of the little DomainSpecificLanguage that the fluent interface provides, but we usually expect methods to make sense in their own right.

An Expression Builder is a solution to this problem. An expression builder is a separate object on which we define the fluent interface that then translates the fluent calls to the underlying regular API calls. So an expression builder for the order case would look something like this.

public class OrderBuilder {
private Order subject = new Order();
private OrderLine currentLine;

public OrderBuilder with(int quantity, String productCode) {
currentLine = new OrderLine(quantity, Product.find(productCode));
subject.addLine(currentLine);
return this;
}

public OrderBuilder skippable() {
currentLine.setSkippable(true);
return this;
}

public OrderBuilder priorityRush() {
subject.setRush(true);
return this;
}

public Order getSubject() {
return subject;
}
}

participation

Wed, 25 Jan 2012 04:10:07 -0000

One of the under-appreciated elements in the success of open source software projects is their modular design, which is an essential element of an architecture of participation.

It's easier for people to collaborate around small chunks, and to build up larger works piece by piece, than it is for them to work together on a large, complex project with many dependencies.

software hacking crisis

Tue, 24 Jan 2012 04:10:09 -0000

*Gene Michael Stover* at http://www.lisp-p.org/controversy

Good software development depends on good software developers: programmers, analysts, managers, testers, & others. Hell, it even depends on good customers.

Processes can remove only so much of the risk of software development. Once you've removed all the risk you can, you must rely on the skills of your people, & they will need to do some hacking.

Hacking is experimental programming to test theories & algorithms, and to work your way through libraries, APIs, protocols, & other tools. There will be kinks in the works for which you cannot plan. The only way to find them is to hack through it. Bottom-up implementation. That's hacking, & you can't develop most programs without it.

The only program which you can design before you code is the program you've written so many times that you know everything it needs to do. (Nope, you can't always put it in a reusable library. Sometimes, you have to write from scratch.) That's the only program you can design completely before you code. And why is that? It's because you've done all your hacking on your previous implementations!

For what it's worth, I don't believe the software development crisis is a crisis. It's just a fact that most software development these days is bad software development. If we never come to the day when most software development is good software development, life as we know it will still continue. Trust me; I know these things.

gathering requirements

Mon, 23 Jan 2012 04:10:05 -0000

Gathering requirements can be done as

- UseCases

- UserStories