Mathieu Tozer's Dev Blog

This Blog is Closed

2008-02-16T04:00:00.002+11:00

This blog has been closed. It represents the initial journey I took while learning my first framework, Cocoa, right from the beginning.

Since that topic is the bulk of this blog, and that part of my life is over, I'm closing the blog. I'll be starting a new code and developer related blog at http://www.mathieutozer.com/code.

Feel free to read the archives or follow along with the new blog!

2007-08-14T19:10:00.001+10:00

2007-08-14 19:09:36.041 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.042 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.052 XXX[2591:10b] animating to: {{50, 62}, {84.8077, 66}}

2007-08-14 19:09:36.057 XXX[2591:10b] animating to: {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.058 XXX[2591:10b] animating to: {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.060 XXX[2591:10b] {{50, 62}, {84.8077, 66}}

2007-08-14 19:09:36.087 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.134 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.168 XXX[2591:10b] {{50, 62}, {84.8077, 66}}

2007-08-14 19:09:36.169 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.169 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.211 XXX[2591:10b] {{50, 62}, {84.8077, 66}}

2007-08-14 19:09:36.212 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.214 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.261 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.261 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.262 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.294 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.294 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.295 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.304 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.310 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.316 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.326 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.326 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.328 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.330 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.330 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.331 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.335 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.336 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.336 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.358 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.359 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.360 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

2007-08-14 19:09:36.362 XXX[2591:10b] {{0, 62}, {84.8077, 66}}

2007-08-14 19:09:36.363 XXX[2591:10b] {{134.808, 62}, {84.8077, 66}}

2007-08-14 19:09:36.364 XXX[2591:10b] {{219.615, 62}, {84.8077, 66}}

etc etc helped me fix that curious bug.

2007-08-14T14:13:00.001+10:00

ZINGLES!!! ZINGLE ZINGLE ZINGLE!!! IT WORKED!!!!

2007-08-14T14:08:00.001+10:00

2007-08-14T14:07:00.001+10:00

About to code something into my project which could either go really well or really bad.

2007-08-14T12:00:00.001+10:00

Thinking it would have been better to not have been so drunk while talking to all those gods and gurus in San Francisco?

2007-08-14T11:50:00.001+10:00

It's funny how I tend to hold my breath while using my own software.

*Just work please work don't crash please please please!*

WWDC2006 Student Sunday notes from the Pixar Guy

2007-08-08T14:50:00.000+10:00

I took these notes at student sunday last year. There's some truisms in there that I like. Thought to share. Sorry about the fragmented nature of them, I was heavily jet lagged! Oh and the guy who was speaking ended up doing a talk in 07 (a similar one). Amazing guy.

-BEGIN-

and that other people can't. It's about giving power to the users of systems.

You're taking things that were in a pipeline, and brining them all together.

Tools are about power.

It's a redistribution of power that works (win/win).

You make a bad thing go away. When you do that, you know you're made a good tool.

Leverage
Passion
It's about following your bliss. Write what you know!
You should be trying to write a real app.

Challenge yourself, but not too much. You want to get better, but be realistic.
Know what you write!

Pick something you know about so you can get better at it.

Join the justice league.

Be world class at something, so you know how it feels.
Pixar hire people because they're really good at one thing.

Have just one thing (even for the interview's sake).

If you've never been really good at something, then you don't know what you feel like, and if you work with people who are better than you, you get better yourself.
Acknowledge your ego, exercise humility.

Play well with you.

Be someone people want to work with.
You know what you don't like in others, don't do that to them.
Become the person you aspire to be.
Learn the skills you need
Meet the people that person would know.
Take the long view

Identify problems by type.

"Yes, it's stupid, fix it"

Or, Actually, it's subtle, and a feature, not a bug.

That was a problem at the last place you worked, not here.

"Nail in the head". Identify problems that you should just not work on.

Just walk away! It's one of the most valuable things you can learn as an engineer. Engineers about the right solutions to something. About elegance.

Criticism.
Seek it out, early and often.
Get it from people who respect you, otherwise you won't get the truth.
Make sure your application is pull not push.
Support promotes ownership, ownership promotes elegance.
If you've only got one idea, you're only going to defend it.

Your first real app
Scalpel, not swiss army knife
assume it will crash, and code accordingly

Smart Lists Revisited

2007-05-07T19:05:00.000+10:00

Thanks to the weeks spent implementing them when I was brand new to cocoa, the word "SmartGroups" strikes mortal fear into mine heart.

--

Luckily my experience has improved and I managed to implement a working system in a few hours! This was for a seperate pet project I did on Sunday.

Grokking NSBezierPaths

2007-04-23T01:30:00.000+10:00

Bezier path drawing (I like to think of it as painting!) - I think I'm finally starting to get it! The possibilities aren't exactly endless, but the power it provides through the simple cocoa interface is exciting, and makes me want to draw more with it!

Quote

2007-04-15T12:47:00.000+10:00

Gunna try and start blogging again.

Here's a nice quite I found:

Of software and sorcery
#
A computational process is indeed much like a sorcerer’s idea of a spirit. It cannot be seen or touched. It is not composed of matter at all. However, it is very real. It can perform intellectual work. It can answer questions. It can affect the world by disbursing money at a bank or by controlling a robot arm in a factory. The programs we use to conjure processes are like a sorcerer’s spells. —Abelson and Sussman, Structure and Interpretation of Computer Programs (1984)

The Craft Of Designing and Building Software

2007-01-20T14:51:00.000+11:00

I learned from MacPaint that in order to get a piece of software to be smooth, you must start over a number of times. You need to test it on a lot of different people and have them use the program. A lot of what I would do was just watch Susan Kare using it.

"What is it that you'd like to be able to do?" I would ask her, "What's the most frustrating thing about this?"

Then I would go back and see what I could do about that. I think that the more user testing a piece of software has, the smoother it can become. The process of software design really is one where you start with a vague notion of what you're trying to make, and that vague notion slowly congeals and gets better defined. As you work with it more, it gets to the point where it is something, but as you try it you realize, "You know, I've kind of missed the mark here. This is sort of what I want to do, but what I really want is more like that!"

For example, first you pit it and pat it, and you realize it's some kind of a table. Then you throwaway all of the code and build a table from scratch, and you've got a clear, clean model. Then you start pitting it and patting it, and adding things that people want and it gets a little lopsided and difficult, and you realize after a while, "You know, what I'm really building here is more like a cobbler's bench." That's when you have to put it aside and build a cobbler's bench deliberately, and craft it to be right for a cobbler's bench. You iterate like that, testing, and then being willing to set aside and build from scratch again. So much software today doesn't get that luxury. Partly because the Macintosh hardware wasn't quite ready yet, I got that luxury. Too many pieces of software today ship when their first prototype is built, and then it's much harder for them to evolve, because they have to keep everybody happy by keeping all of the features the way people have become familiar with.

The original Mac only had 128 k-bytes of memory. Alan Kay referred to it as a "Ferrari with a one-pint gas tank." It was particularly challenging to design a painting program that would do a lot with a small amount of memory, as a copy of the whole screen had to be kept in a buffer to allow the undo command. Bill remembers the worst-case scenario, when you typed using one of the bigger fonts, you had an undo buffer and a selection going at the same time, leaving only 138 bytes free. He knew he could only succeed under those conditions by rigorous testing. Large parts of the Macintosh were rewritten in Assembly language for no other reason than compactness; and later they had to be rewritten again in a high-level language to be more maintainable.

Bill Atkinson, as quoted in Designing Interactions, by Bill Moggridge, page 102 - 103.

試験地獄

2006-11-10T21:18:00.000+11:00

一応試験をとるけど、パスしないと今は思ってい
る。あまり勉強していなかったから落ちると思う。
もう仕方がない。時間をもっと大事にすれば、パス
できたかもしれないけど、もう時間がない。。。
ちょっと悲しいけど。来年どうするじゃ？また大学
に戻る？それかdeferされる？
最悪なのは、AIはとても面白いと前も今も思うけ
ど、教え方は私には会わなかったと思う。それと、
他のアサインメントの開発を本応に頑張ってたか
ら、勉強しなかった。

落ちたらまたこういうことを考えるけど。いや、二
つか三つのある道のプランを作る。
私のこの先のある道：
１。プラスクの三ヶ月間後に海外に引っ越しして、
ソフトを書きながら働く（ワーホリで？）これは
ニューヨーク、パリ、イタリア、ブラジル！！いい
なブラジルって。サンフランチスコ。ゴルドコース
ト。東京！
これは一月の終わりに出発するプラン。ここでサ
マー、海外でサマー！
２。メルボルンに住み続けて、大学の落ちた点数を
また撮る。
３。メルボルンに住み続けて、自分の会社を始まる。
４。他のマック開発している会社を探して、就職す
る。

非実業の専門をやっちゃたので、会社でプログラミ
ング活動をしたければ（したくない）一人で経験を
得ないといけない。

したいくないって言うけど、面白いことをやってい
る会社ならばいいけど。とりあえず自分で働きたい
な。

その三つの道の良い点と悪点をそれぞれ書かないと
行けない。

フォトテーブルを上手にやってたら、アップルにも
就職できるかな？まだ早い？一応頑張る。来週から
本気に頑張る。でも楽しいから苦しくない。

Image Bug Squashed... in one line

2006-10-18T23:10:00.000+10:00

What a hideous, hideous bug! It turns out that the nasty behaviour
that images weren't sticking around between launches (Why is it
loosing objects!!!!) was happening BECAUSE I WAS TELLING IT TO.

It was happening because of the old way the image system was
architectured, before I refactored. Every time the application quits,
images that aren't flagged to be 'kept' are promptly wiped.

And I had completely forgotten about this code and that it was running.

Now that it's commented out, let's see how it all goes.

Yup, sure enough, I comment out that cleanup method in
applicationShouldTerminate, and everything is dandy.

Not sure what the lesson is to take away from this... except that
maybe I'm silly. (Dumb is too strong :P)

I am starting to feel the weight of the application as it grows (and
groans). Perhaps this is one symptom of a growing application.

Setting up SVN remotely

2006-10-18T14:36:00.000+10:00

So now I have a working copy locally on my MatBook, and a repository
ready to manage the source on the server.

Now that the databases assignment is done with, I am going to begin
work on the working version which I can actually roll out at some stage.

Like Pete said, I'll use a rails backend. Currently I'm reading a bit
more about how rails works. Because of my work done in Cocoa, I am
understanding it better than when I looked at it before.

People wouldn't want to log in to use a dictionary. They might log in
to play word games, but the basic dictionary lookup has to be user
free. And if I expect people to submit their own word lists, then
this has to be user free as well.

Construct it as a basic rails app, then open the database up with a
rails api (the type Pete said you could do pretty much for free with
the latest bleeding edge Rails).

So this means I have to
1. Write the database migration, which will generate the database
schema.
2. Modify the model objects to maintain their data integrity, and
increment their counts as required by Words
3. Put up scaffolding, including custom scaffolding, that will enable
simple manipulation of the database.
4. Set up an API for the database.
5. Put the application on a rails server somewhere.

The issue with the rails front end is the inability of unicode. I
know a fix for this is in the works, and there are patch gems available.

Well Uni is finishing this week. Sure I have exams.
I'm actually feeling all depressed about the whole thing really.
Like, almost I don't give a damn. Kind of like I want to just escape
by leaving the country entirely and moving to... India or something.

Kind of like I just want to take off once it's all done.

Maybe I'll stay down in Torquay for a week or something, give me some
time to gather my thoughts. One Week! That would be the longest stay
in 5 years.

Words 0.16

2006-10-17T21:53:00.000+10:00

I guess my problem is that I need to download higher resolution
images of the same image given only the URL. My interface downloads
images by having them dragged into a custom view which accepts URL
drops of thumbs, but then I want to actually download a higher res
image behind the scenes. Is there enough information in the URL alone
to parse another well formed search to the API perhaps? I think there
is - it will be a bit annoying, but doable.

Hey. Isn't it nice when things Just Work. Especially when you
engineered it yourself! I had been thinking all along that
implementing type-to-define search would be difficult, but it seems I
already had the building blocks for it already. All I've done is
create another method, mostly a copy paste of the usual defining
method, but removed the word loop, because I pass it an individual
word. My thread is taking care of getting the definitions from the
dictionaries back to my user interface.

Geez. even the defining spinner gave me feedback on what it was doing!

Having said all that, I haven't tested it fully, of course, but
still, I wasn't expecting to get even this far on the first run.

Words is finally getting to a stage where I could probably start to
use it.

So there that's version 0.16

Some removals, some touches

2006-10-16T20:37:00.000+10:00

Perhaps I need to remove rankings all together from definitions, so
that it removes one of the data entry steps that users have to make
to get concise definitions into words.

Internally I can have a ranking which will be set from the server,
but that's quite a bit in the future. Users should still be able to
order their lists of definitions though.

I'm going to have to go down the list of things I need to finish
before Friday.

One thing is the type to define thing. So that things can get defined
easily.

If I had a dollar...

2006-10-14T20:47:00.000+10:00

If I had a dollar every time I've typed with auto completion

[[blobArrayController arrangedObjects] objectAtIndex:0];

...

Some old thinkin' notes

2006-10-12T19:55:00.000+10:00

This means looking back at the description of what I want to achieve,
and deciding which checks and balances I need to be able to make when
words are inserted and stuff.

I have the basic database system working, now it's time to write the
wrapper to that database.

What I'm essentially doing is writing my very own API! The words API.

Triggers will be called when the user tries to do something idiotic.
What kinds of things are idiotic in the context of Words?

Procedures can be wrappers to adding words and languages to databases.
They can be used to see about sorting a way

They could be used to write API style things. Like "Give me the data
for the game:GameName".
Or for retrieving commonly used sets of data.

They could be written to fetch the interesting statistical information.
They will do the incrementing and calculating of the completeness and
validation levels. They can do the propagation to the rest of the
database of changes.
They will be the interface for the client app to say "Give me
definitions for these words" A procedure will iterate though each
word passed to it and fetch out the words, and perform the updates it
needs to with any new data it finds in the submission.
Basically it has to be able to sync up words together.

I might need to draw a big detailed flow chart of what will happen as
things flow through, and what interactions need to happen to make the
data all sync up.

So what I need to finalise is what exactly I need to do with the data
in the database.

I need some pseudo code about what I need to do.

A Review So Far

2006-10-11T23:04:00.000+10:00

What can be done with my software as it is.
Users can open a language which they are learning, and add words to
it, via a simple push button or though highlighting a word and
selecting a hot key.

Once in the system, users can organise the word as they please by
creating manual groups in which to contain the words, or by
organising them with smart groups. These are all ways in which the
list of words can be filtered.

Users can also search for the definitions of words by the search
menu, and if it isn't already found within your words database, it
will ask if you want to add it. Clicking add will add the word.

Users can set dictionaries which the words they enter will be looked
up in. These are set by checking them in the user preferences window.
More dictionaries can be downloaded from the Dictionary Downloader
view, via a simple drag and drop interface.

Once dictionaries are set up (a once of thing) users click 'define',
which will search all the dictionaries set up to use for definitions.
The definitions found are visible in a text view in the main window.
Which translation language is visible is selectable via the language
list on the left of the window. If there isn't a translation
available in the language they wish, they have the option of writing
one themselves in the main text view. Using the main text view, users
can choose their 'top four' translations / definitions, which will be
used for flash cards and quizzing.

While a word is selected, users can click on 'Find', and a simple tag
search will be performed on the flickr online image database, and a
number of images will be returned. The user can browse the images,
and check 'keep' to save the image against this word.

That is as of Wed 11th October 2006, here's what I have planned for
the future.

Instead of or in conjunction with, users will also be able to define
their words though the playing of games which use what data is
available, and get users to fill in the blanks.

This will happen in a number of ways, which keeps it interesting.

Connect a user with another user with the same language combination.
Let them play games together and record all input. Where the data
input matches, record it as valid. Where it doesn't record it as
needs validating.
This is a general model from which a number of word games
incorporating sound, images, and words can be invented.

Users will then be able to turn to these games firstly as a way of
learning. They will still be able to see their lists of words that
they have encountered though gaming or though reading email in the
regular views. They will be able to earn points towards their total
points kitty, and compete against other players in the game.

All the words will be kept on a central server, and word on the
client side will be kept asynchronously up to date with the servers
words.

Words.sql

2006-10-10T15:08:00.000+10:00

Haven't updated for a while... here's why:
As part of the DB assignment I am building the server side of Words.
I have made an ER diagram of the data I want to be in the database,
converted it to relational tables, then written the SQL code (for
ORACLE) for create the tables.
I have written code to export example data right from the Words
application which can be read by the Oracle database. I have written
'setter' API calls (embedded procedures) for the database which will
conveniently enter this data too, setting the default attributes for
each data item.
I am engineering the database so that it exists in a series of .sql
files, and the entire thing can be set up with a single @words.sql
call at the Oracle command line. You can also clean the whole thing
up by calling @delete.sql.

My next challenge is to develop a more robust API that any client can
call to.
This challenge is from a few angles which I can see:
Insertion of data
Updating the data
Synchronising data between client and server.
Performing complex queries on the data to retrieve meaningful
information which can be used by a client
Searching the data for specific information.

Kinda looks like an API table of contents doesn't it!

Anyway it's due friday so I had better get on it.

Older Notes

2006-10-08T08:45:00.000+10:00

Whittling away at the errors. Taking what I need from other's source code. Making it build, compile. Other people's thoughts and thinking coming though the code. Learning about new coding styles.

Well I'm mighty proud of myself now... it was a long road, but the architecture I've set up to make words extensible for different dictionary types works! I plug in anything, and as long as the new dictionary is compatible with the application's API (actually as long as the correct API is provided by the new plug in) then Words will go and get the blob of definitions in the right way. The next thing to do is to complete the StardictDict class to actually look up blobs from the dictionary it is assigned to.

Next step is to actually do some searching and to move the dictionary in and out of the Words sphere with import and export, so that they can be packaged up and put on a server for downloading via the dictionary downloader.

I need some kind of policy for dictionary naming conventions.

File extension: .wordsDict

Apparently, the unique naming convention I have inbuilt so far is by the "Name" attribute. So I have to make sure this is all unique and stuff, for all kinds. It would be probably best if there are no spaces allowed too. This name can be used for the file name, and also internally to determine uniqueness.

Pivot_Target_Location_Type.wordsDict

Location is probably the hard bit. It would be something like dictDotOrg

It has to be the most.

Think about ordering in a list. Would it be more convenient to order the dictionaries by target? Or by protocol? In the case of non networked dictionaries, location would mean the name that it's generally given. Like en-ja or something. It doesn't really matter as long as it's a fairly unique name.

This means that other protocols can have a en-ja dictionary but still not clash.

Type_Pivot_Target_Location.wordsDict

It all seems to work, still more testing to do, and more data entry to do to support more dictionaries.

Me, a little managedObject

2006-10-05T14:17:00.000+10:00

I spent last night as a peaceful managedObject in his managedObjectContext, without worrying one little bit about all the programming and structure that I was being subjected to in the middle of the night.

I never used to be able to sleep after a serious bout of code, but it seems like as you do more code, you become more content with a nights sleep as an object being pushed around by while loops, being enumerated, and being smothered in objective-C wrappers, or as previously, spending the night as a well formed ascii file.

Has anyone done any reasearch into this thing? I know it's not a programming only thing, but it's when I get it the worst. I'd like to think that it has something to do with the brain learning tings subconciously.

Revolutionary new Asset Downloader!

2006-10-04T02:49:00.000+10:00

I need to bind something to all the words, so what about (yet
another) NSArrayController that always has in it all the words, and
knows about the changes within, so that it can do the stuff like
unpack the definitions for me, and update the UI as needed. Such an
object specifically designed for this purpose might be handy.

Rubbish all the above. All I needed to do was unpack it in the
WordMO. The distributed objects system did all the thread switching
for me!

Moving right along, I need to fix stardicts, because they're kind of
powerful and a major plus for users.

Because it's late, and because I want to, I'm going to work on my web
view downloader. Let's get dictionaries to the people, baby.

Yay! It's 2.40 AM, but I whittled away at it and I can now drag and
drop from a web view to download files. There's a really neat class
called NSURLDownload which is like fully threaded and sick man and
you can even have like progress meters and shit.

Ok bed time.

Threading Issues

2006-10-03T22:09:00.000+10:00

Turns out my sneakly little plan to squeeze information back through
the managedObjects attributes into the main thread is working out. I
AM using a NSMutableDictionary and NSArchiver in the thread, but the
other thread isn't actually working on the objects I create with
those classes, so I'm hoping that will be ok?

I create a dashboard for each word, then archive it up and pop it in
the dashboardData attribute in the managedObject, which has been
passed to the thread through the communications port set up when the
worker thread is instantiated.

The information seems to get though the thread wall ok. My next job
is to unarchive it on the other side and put it where it belongs, as
blob managedObjects in the managedObjectContext proper.

Ahh Finally some progress!

2006-10-02T15:57:00.000+10:00

I'm trying to think of a way to deal with the bloat in my
NSArrayController subclasses, particularly to deal with the issue of
fetching and updating... although it might not actually deal with the
issue... but it would certainly cut down on bloat in those array
controllers.

Here are the symptoms
Words are inserted into the moc
'old' smart lists don't update themselves
'new' smart lists will

So it's almost certainly an issue with the predicates save/refresh
cycle.

I think it has to do with my SmartGroup class. It's a bit of a hack
really. And it also might have something to do with the way I
identify smartgroups and tie them to languages, and how the simple
name value of the language is what is used to fetch words. I think it
would me more intelligent and better design to use the objectID as
the key across the system for language, and to get the name of the
language as needed.

I designed it this way because back then I didn't even realise the
all objects had an ID (well it's obvious NOW) that I could use to
identify the languages uniquely.

I had the idea of doing this, but I found I couldn't set an entire
entity object into a predicate field, but now I can get an object ID
string which will do the same thing as having the object itself.

So while I'm fixing this, I'm also going to try and iron out a few of
those warnings and things which also might be stuffing me around.

Nope, even forcing object directly into the ManagedObjectContext
doesn't fix the problem (it actually causes problems with updating).

What about this idea. What if all I store is a predicate string, and
then when the group is loaded, all it does is force a filter on the
words array controller, so that it filters out the words that I want.
Filtering works nicely. And I can set filter predicates programatically.
So bind the filter predicate of the words array controller to the
selected group of the group array controller. But let's test this now
with that playgroud tableview I set up.

Woah if this thing works, then I have a big lesson to learn about
chucking one's own hard earned code away. I DID have this idea
several times in the past... I hope to high heaven it works!

Tough Titties!
Bad code is bad code.

Hey, it actually feels good to delete it all! And guess what, most of
it was complicated scwisseling code from the CoreRecipesApp anyway.

It IS noticeably slower, so I won't delete that caching thing just
yet. Well it worked just then. Perhaps it's tempremental.
Nevertheless, I have fixed a major bug anyway. Now I have to hook the
other stuff up again and hope it keeps on working!

Flickr Image Search

2006-09-30T01:07:00.000+10:00

Thanks to a handy API, Words now does flickr tag search nicely. It was a bit confusing at first, but the API is well designed as it is and the author has further plans to make it really great, even "Sparkle like".

If I get anything up and running myself, I might even contribute some code to it myself!

Update to Jim

2006-09-29T11:29:00.000+10:00

Posting this here because it's probably the most coherant bit of writing I've done for several weeks! And it explains what I'm doing at the moment, even with all the typos.
--
Jim,

Since we haven't met up for a while, I'll give you a quick overview of
where I'm at with the project. I've been working really hard on it (to
the unfortunate detriment of my other studies) and I'm really excited
about where its heading.

First, sorry for not getting back to you on both accounts re the meeting
and the objects! I have my application working now for onine Dict
protocol dictionaries, which work quite well, and I have recently added
basic support for stardict dictionaries, in a bundled format specific to
my application. One of the goals for Words is to make it dead simple for
users to download and install new dictionaries, and I'm working on a new
interface to do this. I'm having issues with syncs while multithreading I
think, although I haven't attempted to debug that part yet. I'm still not
clear on how to use xjdic (minus the x for X11 part of course) to support
the Edict format within the context of my application, but I'm still keen
to

I've also had some changes to the design of the user interface, which
changes the proposed interaction for the app, and I've thought of a new
direction in which I would like to take the networked side of things.

Following seeing this
video:http://video.google.com/videoplay?docid=-8246463980976635143 I was
insired to aggregate user's word lists and definitions, uncluding images
and sounds, into a central database, in order to construct a user
generated multi language dictionary.

Using some nifty networked, server side wizardry, the details of which I
haven't even begun to fathom, you could make some very fun, data
validating two player quiz games incorporating all the aggregated media.

This also could potentially solve the hard problem of parsing the output
of dictionary searches. Because Words can / will connect to many
different dictionaries, it would be infeasable for me to write a parser
for each one to fine tune the formatting. And who can decide on what
definition is 'main' and should be used for quizzing. I cannot see how a
computer can determine this. At the moment, I call what dictionaries spit
out a 'definitionsBlob' or just a 'blob', and the user has the option of
setting at the moment 4 'main' definitions, which will be used in
quizzing etc. When networked, Words will first query the centralised
dictionary, and if there is a match, it will set these fields for you,
based on other users' submissions on the same word.

And if there is a user community, I could create a plugin architecture
for other interested people to write the 'blob' formatter for specific
dictionaries for pretty printing.

I've also decided against the smaller, minimised view in favour of a
speech bubble which will appear above a word once it is highlighted and
invoked by a right click menu or hotkey anywhere in the system, which
will give you your definitions.

Comments / Suggestions always welcome! It would be great if you had a Mac
so you could test it ;-)

-Mathieu

Blog Lookup

2006-09-27T16:10:00.000+10:00

Old Notes

2006-09-25T18:00:00.000+10:00

I want words to define words in a separate thread, so that it doesn't
take control of the application
But I have to carefully design how this is going to happen?
At the word level?
At the word list level?

I think atomically at the word level it would be best.

I'd imaging that it would work something like this.

Define Word(s)
Start a new (worker?) thread
Pass the words to it
For each word
Start a progress indicator
When the word has been returned
Stop the progress indicator for that word.

Might the network connection monitor actually be better in another
thread too?
But that's not what takes all the time...
The application at any time needs to have connected dictionaries.
Should each dictionary have its own thread?
Or should the one thread manage all connected dictionaries.. or
should a connected dictionary itself be passed to the thread?
Or should a connected dictionary start a new thread for each stream
of words it needs to define?

So, when you ask a dictionary to define:words, it connects (if it
can) and starts a new thread to define the words. And quits when it's
done.

This model might make it easier because I don't have to change much
of the existing code base. But is it good form for a model object to
start a thread? Seems like a controller thing to do really.
But we do want each word to be able to be defining itself atomically
and independently of everything else.
And it would be nice to say "hey, you, try and define yourself!"
which could be done around a loop for each word, and it will go away
and create a thread for itself and look up everything in the right
dictionary etc.

For each word being defined
Start a new thread
Pass the define:word method to it
Kill the thread once the defining is done.

This could have too much overhead with starting and stopping all
those threads.

I kind of need to decide for certain though how I want the system to
define things.
Obviously I want it to try to define stuff for itself, but there also
has to be some way to force it to define words through the user
interface as well.

But this is the way it WILL work, if each dictionary has it's own
thread. So it's dictionary thread centric. A new dictionary thread is
started and is fed a word object which it takes. It does the work of
defining the word, and then defines the word (if it can), and let's
us know when it's done.

So by this, the define method in the dictionary should create the
thread.

I wonder if I start a thread at the point in the code that takes a
lot of time and makes the program freeze, that it will just work. The
new threads will follow along, and return back to the main thread
when the work is done, and just proceed like normal...

Making Improvements

2006-09-25T12:22:00.000+10:00

I think I need to start working to a timetable, with time constraints
and everything, because if I want things to be done in time, that's
how it's going to work.

Besides, it's what happens in the real world. Well I think. I guess
in the case of even Microsoft you ship when it's ready.

I'm still not sure which language/implementation will be needed to
make the server, but again, that would be jumping the gun because I
have to have a thorough idea of what to build before I start deciding
what to build it in.

So leave that aside for the moment.

Get back to the stuff that is making Words!!

Now that I can import and export words, I feel better about killing
the sql file and changing the data model, because I (and users) have
a way of saving their words (the valuable bits) and getting on with
things. So now I can actually start using words a bit more for
recording all those funny words I hear here and there.

yaaay~

The selection of groups is now preserved!! The group you had selected
will be saved for you when you come back to it, whenever that might be.

Now I'm off to take care of my body, by running to Bells Beach

More Musings re Networked Features

2006-09-24T13:49:00.000+10:00

Possible inclusions into what a words attributes should be:
A generalised notes section.
Flag definition as inappropriate / incorrect.
Phonetics
Pronunciation sound byte
Terms (example usages)
Idiomacity
Misspellings, common misspellings and variant spellings
tags?? For categories??
Is submitted.

The system will have to be tested and run for a while to iron out the
bugs and discrepancies that are coded into the system.

After all, it is still meant to be a loose way of defining things.

I guess what I need to do is design this part of the system more
thoroughly from a user interface level.
I need to know what kind of data a user might want about a word.

But how many should I allow?? 5? 10? As many as there are? As many as
there are on the server side, but on the client side, they should
only see their own, and the most popular.

Anyway, I need to set up the stand alone system first, and the
networked version CAN come later.

Bubble Popup specs

2006-09-22T22:50:00.000+10:00

Upon the services invocation to add to words
Determine the highlighted word
Determine the location of the highlighted word on the screen
Start a new bubbleWindow at the location
The bubble window will be a cute little animated thing with some
whispering sounds
Also start asking Words to define the highlighted word
Words searches the user's local dictionary first, then checks the
remote dictionaries second.
The word is added to the user's history.
And a summary of the definition is displayed in the bubble.
The user can click in the bubble to display the word in the expanded
view of Words (the main window).

Multithreading

2006-09-22T19:43:00.000+10:00

It's been amazing the amount of fear that multi threading can instill
in the heart of a novice programmer! It's just such a break away from
the norm. But just now I've seen my first thread be spawned by my
application. Feels like I'm a Dragon Master in a Wyrn. Remember those
threads that rained fire from space?

Nasty Bug, and Words 0.09

2006-09-22T09:39:00.000+10:00

Nasty bug, dance, dance dance!

I'm going to live with it for a bit longer. I've asked the community about it and am awaiting a reply.

Some other changes I've made in the process is to remove the +Smart List button from the main window, as I believe it will be something that the user will only do occasionally, and it is a task which takes longer to complete anyway and thus the added commitment to go to the menu is a small in comparison overhead to adding a smart group (the predicate editor will have to be set etc).

I've also recently decided on a new, secret direction for Words.

So I'm going to move on ignoring the fetching issue on the smart groups after they have been through the data store.

Hmm, the plot thickens! (I know I said I'd leave it aside) If I add a new smart list from the menu - it updates fine! Does it have something then to do with the way the predicate is being stored? It's not being stored so that it can be dynamic when it is fetched? Does it grow stale in the store? Might I work around this by saving it as a string instead and refreshing it when it's loaded?

One thing that's holding be back from developing and exporting dictionaries further is this feeling (assuredness) that the data model is going to change again, which will mean that I'll have to build all the dictionaries and languages again from scratch.

Perhaps the best bet is to simply build the languages and dictionaries to be custom to the testers who are using it.

Words now supports Jargon and Sweedish as languages, with basic dictionaries for those languages available when connected to the internet. These come via dict.org.

スエーデン語をサポートしました。日本語／スエーデン語に訳す辞書がありませんが、英語／スエーデン語はあります。どうぞお勉強を頑張り下さい。

Words 0.09

Yesterday's Thread Notes

2006-09-22T09:35:00.000+10:00

I think atomically at the word level it would be best.

I'd imaging that it would work something like this.

Define Word(s)
Start a new (worker?) thread
Pass the words to it
For each word
Start a progress indicator
When the word has been returned
Stop the progress indicator for that word.

So, when you ask a dictionary to define:words, it connects (if it
can) and starts a new thread to define the words. And quits when it's
done.

This could have too much overhead with starting and stopping all
those threads.

So by this, the define method in the dictionary should create the
thread.

More Notes

2006-09-21T20:20:00.000+10:00

An undefined words smart group.

Perhaps try to implement the speech bubble as a plain box first that
appears with a definition. But before that happens, I want more stuff
'up top' to be working sufficiently.

I REALLY don't know the answer to my core data issues... :-(

Returning to Defining Words With My New Found Dictionaries

2006-09-20T21:29:00.000+10:00

Now that I have set the architecture up for importing and exporting
languages and dictionaries, and then setting them into the project
bundle to be part of the next release of the software, I feel I must
return to the actual looking up of words, when that happens, and all
that.

Primarily, I want it to, as per the spec
a) Attempt to define words *as they are entered*, and display and
indicator to that effect.
b) Attempt to define undefined words.
c) Be able to wipe definitions clean.
d) Fix the network awareness.
e) Let the user know when nothing was found.
f) The definitions view, but that's another whole kettle of fish.
g) Implement the buttons which add the main definitions
h) When defining words, display a spiral progress indicator and let
the user keep working with Words.

yes yes Indicators Indicators INDICATORS! It's time to start telling
the user what's happening when Words takes control of the computer.

Another thing to think about is what I'm aiming for for first time
users.
1) Launch Words
2) See Some Example Languages Already Set Up (Maybe??)
OR show the add languages view
3)See the example words be defined automatically by the system.

I wouldn't mind having an even closer to user interface like a bubble
that appears above the highlighted word text.

It might be best for me to have a worker thread for defining words.

Language and Dictionary Management: Next Steps

2006-09-19T22:35:00.000+10:00

Now that I can safely import and export dictionaries, it is up to me to
a) Add support for as many dictionaries as possible.
b) Create more languages which are supported to match those
dictionaries.
c) Implement the add all supported dictionaries on startup procedure.

The problem is that sure, on first launch, import all the
dictionaries. But what about on updated versions of words? I guess if
a person is HANDED a dictionary, then they use the regular import
command.
We are only talking about importing the supported dictionaries here,
the internal ones. So it is sufficient to add them all, or more
precisely, add all the dictionaries to the store on launch that
aren't already in the store.

This will slow start up down efficiently, but let's see how it goes.
The dictionaries are fairly light, and it wouldn't be too hard to
optimise the checking with versioning.

It seems to work. Haven't fully tested it yet though
The question is now, of course, will it scale, and work well under
the pressure of the real world as opposed to the toy world situation.

Dictionary Management Advancements

2006-09-19T17:01:00.000+10:00

I can now use the dictionary factory view to pump out dictionaries.
I still have more work to do to get it exporting those dictionaries,
and from there I still have to implement the 'available from launch'
dictionary method.

I am really excited about finishing this off because it is one of the
final fronteirs to getting words up and running the way I want it.
Until now it has been very touchy, and quite unusable to anyone but me.

But since I have started to implement the advanced dictionary and
language management, having kind of finished the word management
side, I feel more people will be ready to use it, because I can pass
them new dictionaries and languages, and then add them to the next
release of words.

There is still quite a bit of work to do, as I said. But it's nice to
see it coming together somewhat. I'll try to release Version 0.08 soon.

Language Management

2006-09-19T16:34:00.000+10:00

It is now possible to create languages in the 'language
factory' (including an icon) export them to file, import them from
file using the language factory. Words will also look for files
contained within the bundle and display a list of them to choose from
in the 'supported languages' list when you add a language, and the
language will be added when you click add.

The next thing is to do the same for dictionaries, and see if it all
matches up. Perhaps language objects can keep an array of dictionary
names that it will try to set as 'in use' if they are available.

On export
Put all the dictionaries that a language should try to set itself up
for when initialised into an array and archive it with the rest of
the language.

On import
Fetch dictionaries to that capability.
Take the array and search the available dictionary names and if there
is a match then connect it up!

Words will also need some initialiser text - the text that is
displayed first when you import a language.

But now I think I need to talk about dictionaries.
They need to be created, for whichever type they are, able to be
exported, and then fetched by the system when it loads, imported into
the user's database (not the whole file of index / definitions for
local dictionaries of course, just their Words management part).

Once I manage to get it into the managed object context, the existing
code should take care of the rest.

Changes To Internal Language Management

2006-09-18T17:49:00.000+10:00

I'm going to remove the second context because it doesn't really make
all that much sense to have a second managed object conext. It would
be better to simply have an import exporter function and automate
this process on the first start up or something. Ie, just keep them
in the bundle as .wordslanguage files or something.

What is the goal of what I'm working on now???
To be able to have the user select from an internally supported list
of languages which have dictionary files already set up to use.
So be able to export and import dictionaries first.
Then implement a way to insert these dictionaries into the user's
dictionary sql file so that can start adding and learning words.

It is perhaps more intelligent to leave the dictionaries separate
from the languages when archived. This way languages too can be
passed about freely, without the weight of dictionaries attached to
them. Although it is not intended that languages be passed about as a
commodity like dictionaries will be.

Therefore when the user clicks export, a neat little bundle of
archived language data will be exported somewhere.

When a user adds a new language, the supported languages bundle will
be searched, the contents (or just their names) unarchived, and then
presented to the user. The user will then choose one of the supported
languages and then it will be copied into the user dictionary.
This way unneeded and unused languages won't be making the database
heavy.

So the next step is to enable languages to archive and unarchive
themselves.
This would include the words and that come default with that language...

The final release will be fine tuned, so leave that for later. Make a
simple import export method for what a language constitutes today.

Done! In a single train ride.

This stuff is too easy.

New Version 0.07

2006-09-16T19:03:00.000+10:00

More meaningful startup messages when there are no languages
available, and libraries are now 'soft' fixed because of this new way
of adding languages. You can see the beginnings of the factories to
produce internal languages and dictionaries, but they are not
operational yet, so don't use them, and you can get a feel for where
I'm going with that.

You can also quiz yourself on a list of words by clicking the quiz me
button.

Words 0.07

Quzzing System

2006-09-16T10:43:00.000+10:00

Have added a rudimentary quizzing system which was surprisingly easy
to implement. Hopefully other learning features will be a simple
matter of grabbing what's in the word array and playing with them in
whichever way!

It's still rudimentary because actually it relies on the 'main' defs,
of which there is still no fully implemented UI to specify. Might do
that next.

No languages defined - means that the intro tab is shown in the main
view... which gives a brief description of usage, and also allows one
to define one's first language to learn.

I want Words to ship with a number of supported languages and
dictionaries, so users can get started right away.

But where to store this data? The likely place is in a separate core
data managed persistent store. But how do I create this database?
With words itself? After all, the persistentStoreCoordinator will
just look for the sql in the spot that I tell it to. If it's not
there, then it should scream, but thing is, if it's INSIDE the
application bundle itself then there is no reason why it shouldn't be
there.

So let's say we have a separate managedObjectContect to manage
'wordsSupportedFilesData' or something like that. Something other
than what I've forever been calling my 'managedObjectContext. It
would be bad programming but it would be fun to call it
'magicObjectContext' :-)

So, if I set up this new dashboard, then I can copy objects from this
one dashboard to the next without much trouble.

Well it took a little bit of staring at code, but now I have two data
stores. The new one is to store my internals...

Burn Out

2006-09-15T09:31:00.000+10:00

I think I'm a little burnt out...

There are times when you look at it in think, why! Why won't this
work? Will it ever work? And then you think - what if it doesn't? And
even if it does, is anyone going to use it anyway?

Maybe it's time to take a quick step out of implementation land and
look at what end goal I am looking at.

One major area is the definitions view, because I can manage all the
words I want in neat little smart groups, but if I can't learn the
meaning of new words, then words is useless, right?

The definitions view should have some kind of divider between entries
Should be able to indicate where the definitions came from.
Should have some kind of mechanism for choosing definitions. This
must be 'quick and sloppy'.

What about a highlight and click system? Highlight the text that you
want to be set as 'main' and then click a button or press a hot key
to set it. E and D or D C or something configurable.

Extensible type system? Can people actually be bothered with this?

It's an added extra that we might not even need to worry about.

What if the goal of words was more general, so that it was a defining
system for any kind of terms?

Then a dictionary would be simply a data source, somewhere to get
data from.
Google:define etc.

A big chunk of dev notes

2006-09-14T08:46:00.000+10:00

I have made 6 basic releases through sparkle now, and have gotten
some valuable feedback. Further, I have made some improvements to the
system.

I am sick of my crappy grouping system not working properly, and I
had a brain wave. Why not just bind the groupsArrayController to the
selection of the languageArrayController and ask language objects for
the aggregate lists? This seems to work nicely, and updating is all
working *for free*. I have to work on adding and removing objects.
I've got this working, but the array controller isn't refreshing
itself (you still have to click off the view and back again).

Just to clean off my desktop, here's some other dev notes from the
past week.

------

how about some highlighter tool that lets you select the text to be
used in quizzing? So I dump the text, and you just choose what needs
to be used by highlighting.

So the next step in usability for me is to have that freeform space
for defining words.
(which includes images)

So today's goal is to have that free form space available.

Could even use google define and wikipedia search for terms.

And I want the flow of the program to be more intuitive to 'flow'
from the search bar, as you would in a regular online dictionary.
This will help people ease into using it. So you enter a word in the
search bar, the most natural thing to do, and it tells you

"WORD not found in MANUAL GROUP or in LANGUAGE, looking up word in
ENGLISH dictionary

Add WORD to ENGLISH?

And all the user has to do is hit enter to add it to their list.

Find out how it works (dict.h) and import it into words.

Sweet! Now I can export dictionary objects. It was fairly
straightforward.

Funny how when doing something for the first time in Cocoa you kind
of hold your breath, and loose confidence when things go wrong, but
then when it all comes through you feel more confident about doing
the same thing again elsewhere, and you also realise how simple it
all really is!

With this newfound knowledge I should be able to import and export
dictionaries at will from Words to Words, so that users can download
dictionaries of type 'wordsdict' willy nilly from my website, or be
emailed them from friends, or whatever, and then import them into
their dictionary managers.

I just thought of a nicer interface for managing dictionaries. What
about a column for selecting the languge onb the left, with the
number of available dictionaries in brackets on the right.
English (4)
Japanese (3)

Selecting them shows the current view. Shouldn't be hard to do.

Anyway before doing that it's time for an SVN commit.

The next step I think to make it usable is to support some local
dictionaries, not just remote ones.
I should at this point Finalise the model attributes for dict
protocol dictionaries, because if I am going to start passing
dictionaries around, then I'm going to need them to work with later
versions of Words.
I will also need a way to perhaps modify a dictiionary's attributes.

It's funny the way I cross my fingers every time I commit something
to SVN, because I expect I've broken something in the process.

Drag and Drop system. Moving Words around the system fluidly,
wherever the user wants.
Take the selected words
Bundle them up in the drag operation
Drop them on something.

Which means that group objects and languages need to know how to
accept dropped bundles of words, and manage that appropriately.

I have implemented some basic drag and drop functionality for moving
words around the system.

What about if words actively supports some languages, but still lets
you use Words for languages what aren't actively supported? What
would the difference be?
Making sure that encodings work on certain dictionaries which are
provided.

Custom view for the definitions view. So you can send it
notifications to display certain things, and to behave in a certain way.

Wrap the table view in a custom view... maybe a tab view?, and
connect it up in the same way... then register the custom tab view to
change itself upon receiving a notification or an invocation of a
certain method or something.

How about 'edit type' for word type?? So that the user can specify if
they want. Otherwise, the available types are defined by the
supported language.

It's going to have to register for some3 notfication so that it can
run code when there is nothing or something in the wordArrayController.

When you search in the box, should you be searching for words in a
language, in all language, in the selected list, or what? What is the
scope of the search??

Words Very Beta 0.04

2006-09-12T18:24:00.000+10:00

Here's where I'm at.

Stiiiil not happy with groups

2006-09-11T22:39:00.000+10:00

Dear oh Dear.

I'm having bindings woes.

It's probably because either me or my bindings aren't gluing together
and being in sync.

Perhaps there's a better architecture for this?

I'll give it a rest tonight.

Drag and Drop

2006-09-11T14:58:00.000+10:00

It's funny the way I cross my fingers every time I commit something
to SVN, because I expect I've broken something in the process.

Drag and Drop system. Moving Words around the system fluidly,
wherever the user wants.
Take the selected words
Bundle them up in the drag operation
Drop them on something.

Which means that group objects and languages need to know how to
accept dropped bundles of words, and manage that appropriately.

I have implemented some basic drag and drop functionality for moving
words around the system.

Dictionary Import and Export via NSKeyedArchiver

2006-09-09T17:11:00.002+10:00

Sweet! Now I can export dictionary objects. It was fairly
straightforward.

Selecting them shows the current view. Shouldn't be hard to do.

Anyway before doing that it's time for an SVN commit.

Better Dictionary Management

2006-09-09T17:11:00.001+10:00

It's funny the way I cross my fingers every time I commit something
to SVN, because I expect I've broken something in the process.

I'll try to set up some networked dictionaries for my future beta
testers to download, import and use. That should get things started.

One day in the future it would be nice if you could download them
from right within words!

Dictionary Plugin Architecture

2006-09-09T17:11:00.000+10:00

Has words gotten to the point where I can almost say I have basic
word management working? Because then I have to move to a slightly
higher level and add in the stuff that makes that basic functionality
more usable.

Dictionary management is hard. I think that's why I'm sort of
ignoring it a bit.
But I have to have it work!

Which means thinking about how the system will add certain
dictionaries to itself when the program loads (for the first time).
Or is it better to ship words with a bundle of dictionary entities,
all neatly archived up, which are added to the user's own data
model.... this way the the sql database can still be kept in
Application support, but the available dictionaries can be added and
changed by me through the bundle.

I would have to fully specify and insert all the server and
dictionary database, set which languages it can translate to and
from, test them, paste all the needed info into the dictionary
(dictProtocolDictionary) and then put it in an archive that perhaps
the user can download.
The user could specify his own dictionary objects through the add
custom, or just download the ones I've specified and import them in.
That way, the user can abstract as a 'word's dictionary.

The dictionary files themselves objects would have to be kept in some
seperate store.

It would be nice to be able to:
Define a custom dictionary in words. EXPORT IT as a bundle.
Upload it to the net, have everyone else download it.
IMPORT the dictioanry file into their own words model

Having said that, I should be working towards building an import and
export function in words for dictionaries.

Essentially, it should be something along the lines of, for the user
(myself included!)
EXPORT
Select a dictionary in the dictionary preferences view.
Click export
choose a location for the file (filename wordsdict)
click export

IMPORT
Select import Dicitonary from the file menu
Select the wordsdict to import
click import
Give confirmation of the import
See the dictionary in the dictioanry preferences window.

More ideas re: defining words

2006-09-07T18:31:00.000+10:00

how about some highlighter tool that lets you select the text to be
used in quizzing? So I dump the text, and you just choose what needs
to be used by highlighting.

So the next step in usability for me is to have that freeform space
for defining words.
(which includes images)

So today's goal is to have that free form space available.

Could even use google define and wikipedia search for terms.

"WORD not found in MANUAL GROUP or in LANGUAGE, looking up word in
ENGLISH dictionary

Add WORD to ENGLISH?

And all the user has to do is hit enter to add it to their list.

Find out how it works (dict.h) and import it into words.

Yay! Blob style auto definitions

2006-09-07T18:30:00.000+10:00

Images will be displayed in the main window, and because I want to
show many images, I want to be able to cycle through them.
I would like to enable the user to show the images in a grid view, or
to cycle through them.
When images are being searched for, a progress indicator should be
shown.
Images that are not relevant should be able to be removed from the
view and thus deleted.

I propose an array, or a set, which holds images, that can be
unarchived and shown in the view.

Phew

It took a bit of fiddling around, but I seem to have the blob thing
sorted out. Turns out I was trying to put a mere mutable string in a
text view, when it needs to be an attributed string. The archiver was
dutifully saving it for me in the textblob attribute in the core data
entity for definitions.

I think I have a more usable program already!

However

Mincing steps, Mincing steps....

App Casted: Words 0.0 (VERY Beta!)

2006-09-06T23:47:00.000+10:00

I've made an app cast, put the sparkle frameworks in, and am now
serving Words 0.0 to a select few to try out.

I'm not ready to get too excited about it yet because the software
isn't anywhere near being done, but it's neat to think of it being
"App Casted" about the place.

Remembering that it's really nowhere near show-able to anyone, I've
released it to a few people.

Here are the release notes.

Known Issues
Grouping System
Updating of groups upon deletion is slack. Lack of GUI to predicate
setter is a barrier to usability. Ordering of the group system is
random.
Dictionary Lookup
Not recommended at the moment, behavior unpredictable! Use the
definition button to manually add definitions. That's your safest bet.
Definitions
Meaning / Definition table view is not complete, proposed system is
to have a 'fat' table view so you can see the whole dump of
dictionary text within the one cell. Comments on this please!
No Icons!
Any icon designers out there??

Roll Back to Old Groups

2006-09-06T21:50:00.000+10:00

After trying to refactor the groups system, I have decided to roll
back to a previous and stable version. I am spending too much time
trying to get it working again, and the benefits of doing so are
slowly dissapearing, as my original solution worked just as well as
the refactored one would.

Through this exercise I have learnt again the value of version
control, and also the lesson of not refactoring too soon on in the
development process, especially if the current solution is working
and efficient. In fact, I was refactoring simply for the engineering
simplicity of the refactored model.

So now I have to
Take some screens to show what I was attempting
Take a copy of the nib, as the UI has been changed since re-factoring
as well.
Export a copy of a previous revision of words from the repository.
Import the new export in a branch of the Words directory
Delete the export
Checkout a new working copy of the roll back.
Incorporate the new network awareness components into the new
checkout model
Continue development...

I've also learnt that working on more than one thing at a time can be
an issue because if you need to roll back past those changes, you
have trouble!

Actually I was smart in not letting that happen, by not committing
broken versions of the grouping system.

So actually all I needed to do was
Delete the crappy one
Checkout a working copy from the correct revision.
Revert to my old backup sql database that I had prudently kept
against this event.
It all ran and loaded with no problem with all my old words and
languages in there!

Groups (AGAIN YOU ASK!?)

2006-09-06T09:49:00.000+10:00

Bah! Silly me hadn't even put the framework I was including into my linked frameworks folder. Is compiling and linking fine now.

The best way to describe the grouping system is IFFEY.

I should redesign it so that one array controller contains all the list objects in the system.

Anyway.
My goal today is to have the dictionary lookup system working satisfactorily. It must only look up dictionary definitions or attempt to if the system can connect to the server.

I kind of need to be able to toggle the internet connection somehow, which means developing within an active internet connection.

How do I do progress indicators? How do I have something processing in the background but still have the system responsive?
Is this where multi threading can help??

Well, accumulatively I think I've spent 15 minutes refactoring the groups system, almost purely using bindings and a proper core data model, and what I spent weeks trying to achieve myself (and succeeded, mind you), I've made work in 15 minutes.

The lesson learnt here is... well... don't be too afraid or too proud to completely write off all the code you've spent a long, hard time writing (on a Greyhound bus in California), because bad code is bad code, no matter how long it took to write it.

Been thinking of new titles for myself and my web blog, which is kind of due for an update I think. I want a wordpress blog with tabs to the different sections.

An interesting mix of Model/Computer Programmer (Yeah, I know)
Model/Computer Programmer (Yeah, I know)
Mac OS X Application Engineer / Model LOL

Just what am I!?

Refactoring Groups

2006-09-03T21:58:00.000+10:00

Bah! Silly me hadn't even put the framework I was including into my
linked frameworks folder. Is compiling and linking fine now.

The best way to describe the grouping system is IFFEY.

I should redesign it so that one array controller contains all the
list objects in the system.

Anyway.
My goal today is to have the dictionary lookup system working
satisfactorily. It must only look up dictionary definitions or
attempt to if the system can connect to the server.

I kind of need to be able to toggle the internet connection somehow,
which means developing within an active internet connection.

How do I do progress indicators? How do I have something processing
in the background but still have the system responsive?
Is this where multi threading can help??

Well, accumulatively I think I've spent 15 minutes refactoring the
groups system, almost purely using bindings and a proper core data
model, and what I spent weeks trying to achieve myself (and
succeeded, mind you), I've made work in 15 minutes.

The lesson learnt here is... well... don't be too afraid or too proud
to completely write off all the code you've spent a long, hard time
writing (on a Greyhound bus in California), because bad code is bad
code, no matter how long it took to write it.

Been thinking of new titles for myself and my web blog, which is kind
of due for an update I think. I want a wordpress blog with tabs to
the different sections.

An interesting mix of Model/Computer Programmer (Yeah, I know)
Model/Computer Programmer (Yeah, I know)
Mac OS X Application Engineer / Model LOL

Just what am I!?

Network Reachability

2006-09-01T20:14:00.000+10:00

Words is now network aware, however it is not exactly as I would like it.

See, it would be ideal for it to check the reach-ability of individual servers, rather than just any old server. And as it stands, if one server is unavailable, all servers are made unavailable.

This has to do with bridging the gap between the C and Objective C. I have only worked out a way to make the callback function

<>

Thank-you Shawn!

Network Awareness, It's a bit of a hack, because, one click of define will connect the networkObject, then you would have click again to actually do the definitions if you actually were online. The current implementation is such that it assumes you are offline to begin with, which is not what I want I suppose... the one click should show if you are online or not, then act accordingly. Tried the use of sleep but didn't work. Otherwise it's working pretty well I think.

Memory is probably leaking too. Might try to use the Leopard Developer tools to solve that one.

Yeah so it's a bit of a hack really. But it will work for now methinks.

USe http://www.cocoadev.com/index.pl?ApplicationLinkingIssues when looking at sparkle

Bugs Squashed, Frameworks Fixed (deleted), All at Tequp!

2006-08-30T23:04:00.000+10:00

Just spent about 7 hours at 'tequp', a Melbourne tech meetup with the guys from plasq, and plenty of others. It went quickly though and Pete, Keith and I ended up having vietnamese on Victoria St afterwards (which took us to 10pm)

Demoed my app to them and Keith and Cris both gave great UI and interaction advice. Much appreciated guys. Thank-you!

Also today I squashed a long standing linking error in my libdict framework, and I also took libdict OUT of a framework and put it right back into the main project. The framework was too finicky, and too much overhead for so little value really.

So that error was fixed too.

So seriously the next step is to stop that crash when offline or when something can't connect properly, because otherwise it's stable.

Then it's time to sparkle... :D

Planning Features

2006-08-29T21:45:00.000+10:00

Well the whole purpose of this is to get definitions from dictionaries, right?

So let's make Words look up words.

Again back to the UI drawing board.

Words should try to define themselves on awakeFromInsert
They should know when they have been defined (checkbox)

The application should be able to go through a list of words and define all the ones that haven't been defined yet, when the user indicates that it should be done (maybe via a menu system).

So I have to write awakeFromInsert{}

Maybe I need some kind of utility object that any object can just ask for definitions through. Like something awake from nib in the app delegate, and the object can be given to any other object via an accessor.

This way the words themselves and their controllers (like the thing that goes through a list) can use it to define words.

HEY! It worked first try. It's really nice when things JUST WORK!

It's funny though how you can get something working, but then not want to try it out TOO much for fear of breaking it. Well I'd better get over that, because for my app to survive in the real world I can't allow people to tiptoe around it all the time! So let's really try it out.

[] Connect only once per launch, reconnect as needed.

Ok we had some issues. They have to do with failing gracefully. The one noted above about connecting only once per launch, not every time the dictionary entity object is fetched is important.

Another important modification that needs to be made is with the UI of defining dictionaries.

It took a few minutes of beach ball time, but 171 words auto defined at once, right there, but what good is a definition if you can't read it in the table view?

[] eliminate duplicate words when importing.

But shit, look at that. 171 words and the sql lite database is already 1.4 megabytes. I hope core data is up to the challenge! Access time is still reasonable though.

Use sparkle to distribute from the start so that testers are kept up to date with the developments.

I've been looking at the Cocoa APIs which will let my application know about the availability of networks.

This is what I think it should look like

And for word input, there are a few things I need to implement

This part is also important too for the viewing of definitions

I'm dreaming of the time when I can seed testers with my app.

Along with sparkle, I would like to have a 'feature request' and 'comments / suggestions' menu item which emails them right through to me.

Also, when adding a smart group, I'm still getting all the English words in the Chinese words list, which might mean that when I am creating words in the services menu, I am not properly associating them to a language. Or it could be that the smart group is still fetching for all languages from the moc rather than for the currently selected language to which the smart group belongs.
So what's next?

(Almost) Managing Dictionaries

2006-08-28T13:57:00.000+10:00

And here's the notes that made it all come about:

I still have to think again about how the dictionaries can associate themselves to more than one language. Right now a to many relationship can not effectively be set because there is only one pivot language.

Maybe playing around with the software will be more effective in determining what will work.

I was thinking it would be nice if the dictionary always translated to your native language. What if I could get that from the system? But I decided that wouldn't be helpful anyway, because it's dangerous to assume that there are going to be always dictionaries available to translate to the user's native language.

Ideally, what kind of setup do I want? I should implement a design. The design should force the implementation, NEVER the other way around.

I've been dangerously creeping toward this so watch out!
------------------------------------------------------------------------------------------------
Checked dictionaries will be used in looking up definitions for JAPANESE
Here are the dictionaries that have Japanese capabilities.

------------------------------------------------------------------------------------------------

Obviously the UI won't be so verbose, but it's helpful in determining what the implementation needs to cough up stating it in this way.

Which means that the display shouldn't only show which

Another problem is that I've set things up to work for lookup in a unidirectional manner... but.... that's kind of what Words does. It's unidirectional. Think about it.

Users say they're learning "Japanese"
But it also means that they're going to want to translate words from English INTO Japanese. How will words support this?

Back to the UI drawing board.

What would be nice is if the program KNEW which language the word being input was.

Ok, so here's what I thought on the way home.

The language will only know to ask along that pipeline for definitions, for whatever it considers a word. Therefore it's left up to the dictionary itself to spit definitions of the word back, or not to.

So the dictionary manager should show the user a list of dictionaries that declare that they have the capabilities in EITHER direction for the currently selected language, and that I have been in error over the 'pivot' language idea.

So I have to modify the predicate to be in accordance with what I have decided here. It might be wise to modify the model to have a 'capabilities' attribute.

So the predicate will be more like:
(capabilities contains[c] 'languagename')

And then the user will be able to check the box to associate it with the currently selected language (ie, connect the pipeline).

yeah! I think I got it working alright.

See, I forgot about an old friend called [App delegate]

Which gives you the object that is pretty much available to everyone, including model objects, which use it all the time when asking for [[App delegate] managedObjectContext];

The next step is to set it up to actually do some word defining.

New Design Decisions for Dictionary Management

2006-08-27T23:08:00.000+10:00

I'm trying to work out what the filter predicate for the
availableDictionaries arrayController should be.

It should fetch dictionary objects that have a pivot language that
matches the selection of the languageArrayController.

availableDictionaryController.filterPredicate =
languageArrayController.selection.name == Dictionary.pivotLanguage

(name contains[c] $value) or (pivotLanguage contains[c] $value) or
(targetLanguages contains[c] $value)

(name contains[c] $value)

Words: Have made some good progress in dictionary management today.
Still having some issues though. It's stable but I don't know how to
update the view each time a dictionary is added, and I can't get it
to show only those dictionaries that apply to a certain language.

Maybe I can put a clause in to say
if currentLanguage.name is null, then skip this part

I'm also going to have to make a design decision about whether a
dictionary can be used for more than one kind of language or not. As
it is at the moment, a dictionary can only be used by a single
language. But what if a dictionary looks up both Japanese and
English, both ways, and a user is a native Japanese speaker, but
wants to have JPL-JPL and ENG-JPL dictionaries. It doesn't make sense
to have two different ones, it would be best to use the same
dictionary for both 'languages'. So its a many to many relationship
then. The next task is then to, when the selection changes, the
dictionary view updates itself so that all the checkboxes reflect if
the current language is using them or not.

Dictionaries with a checkbox to set relationships up.

2006-08-27T14:58:00.000+10:00

I've run into a bit of trouble with implementing this drag and drop interface for dictionaries, and I think it has to do with the limitations of bindings and core data.

But I just had a thought...

Wouldn't it be better to just have a checkbox to indicate which dictionaries are 'active' or not? This is probably better UI and it's certainly going to be easier to implement too!

But it has been good to fiddle around with this because I've learnt about how the drag and drop mechanism works, and how I can set it up with my other tableViews in the future.

Is setting a relationship the only way to go about it? Is it the best way? Why not have the system merely go though the whole list? There would be less processing and room for error if I set the relationship, and it also ties the dictionary object to a particular language, which is what I want.

The arrayController says, give me all dictionaries for THIS language. The model objects themselves know which language they are applicable to (by language name KVO) and they also know in their model if they are 'in use' or not.

Ok it's talken an afternoon but I think I can see this working.

In fact I got right down into the debugger MAKING SURE that what I thought was happening was actually happening. Asking it things like [[languageController selectedObjects] objectAtIndex:0] which help with seeing whether core data relationships are being set and removed as I want them to.

Going to go to the gym now for a bit of physical activity :-)

Then back to it!

Dictionary Management to Drag and Drop

2006-08-26T19:13:00.000+10:00

Fixed the SVN commit but just creating a new folder for Words.

Seems like this skeleton I'm building should work in the end.

Does every language have a pivot language?

What if the array controller just fetched ALL dictionary objects, and I set a filter on it which can then further be filtered by the user searching with a search field to narrow it down?? If that was even needed. They will easily be able to see by looking at the table view which language the dictionary being reperesented will translate to. I don't need to do EVERYTHING for them!
That's the way to go about it!
Just chuck a dictionary into core data, and fetch it as I need it by setting the predicate on the arraycontroller.

Here's the pseudo code that creates dictionary objects
// interface action which gathers the needed data and creates a new dictionary object.
- (IBAction)createNewDictionary:(id)sender{
//get the currently selected language.
//create a new dict protocol dictionary (because that's the tab view that is selected)
// create a new dict protocol dictionary in the moc
// set the name, server, database etc
// test the connection
//if connection is bad, report error to errorField
// set the target language to current Language + xxx (for use in fetching)
//close the window (and dictionary should be fetched by the arraycontroller to show in
// "available dictionaries"
[customDictPanel close];
}

Working on drag and drop using sample code from mmalc and other Apple documentation.

System Apocalypse

2006-08-26T10:42:00.000+10:00

Boy did I have some nasty stuff going on for the last few days!
Installed Leopard, archive and installed Tiger, trying to migrate user info over from backups etc.

It still feels like I'm not using my own computer yet, but I'm getting there.

On the bright side (of XCode being broken, and taking 3 reinstalls and kills to fix it) I have somehow freed up 10 GB or so of space on my main drive, which is great considering I was always pushing up against FULL. Turns out all those libraries were adding up to a whole lot of crud.

It's not quite dlll, but it's certainly Library hell!

And it does feel refreshing because it feels like a new computer.

On the Words dev side, I have had a meeting with Jim Breen and discussed dictionary formats.

I'm going to support the EDICT format next.

But first I must have the dictionary management system up and running.

Dictionary Management Design Notes

2006-08-25T22:41:00.000+10:00

The UI of the dictionary management system.

As documented in my specifications document,

In the preferences menu, only the dictionaries that are applicable to the languages the user has defined should be shown, this is to avoid long lists of languages for the user to search through if the system actually supports many languages.

Disadvantage is that yes, you won't be able to 'browse what's available' but MOST people won't be bothered with that anyway.

The view will be bound to a something which will tell it which languages are defined. (The language array?) Something will take the language names and use them as keys or fields in a predicate which will fetch the dictionaries that are applicable to that language combination from the 'bag of dictionaries' in the managedObjectContext.

On the left hand side of the preferences pane will be a view displaying all these fetched dictionaries. On the right hand side will be a view of the objects on the left hand side that currently have their relationship set to the language object in question. Ie, it is being used in finding definitions. If the language is in the right hand view, then it should be visible, but greyed in the left hand side.

View:
The two 'available dictionary' tableviews
Language Chooser in the preferences - > dictionaries pane
The create new dictionary

Controllers:
This is always the tricky part.
I'll use the language array controller to see which languages are available.
The controller should manage the creation of the new dictionaries.

Model
Dictionary Objects
Some related to languages, some not.
A generic dictionary entity which more specific dictionary types can be children of.

I would also be nice to have the preferences in a separate nib file.

I need to decide which dictionaries I am going to support, and how. Actually, I should engineer it so that I don't have to make that decision at all. The software should be extensible.

So let's start by looking at managing whatever the dictionaries might become. Build the framework for the dictionaries and fill in the details later.

I have to think about what all dictionaries have in common.

Perhaps I should just directly bind the combo box to the languageArrayController, after all, it is likely that a user has been editing in a language and has decided to check or change the dictionary preferences. And there is no harm done in switching languages in the main view when changing preferences, in fact this could be a feature of the application. Kind of like a big context switch from language to language.

What To Do Next

2006-08-22T01:31:00.000+10:00

What should I do next?
I'm at a bit of a loss at which feature to attack next.
Dictionary lookup? This is the crux of the app, learning the meaning of words. So having the meaning there should be paramount!

There are core features, essential to the application, then there are the auxillary nicieties that yes, must be there, but are easier to implement when you have the product features there to prop them up.

For example, I couldn't hope to implement drag and drop before I had implemented the grouping system.
And before I have a dictionary management system, there isn't really any point in making a lovely preference pane or tool bar to hold the pretty icons.

So I could probably work on the dictionary lookup system.

Thinking about the problem.
Dictionaries are managed by core data. Their attributes and association to a language are set up so.
However, how am I going to make it possible to give suggested dictionaries to users, as well as allowing them to define their own custom dictionaries?
And I'm going to want to be able to see them in the same view.

Starting at the elemetary level of a dictionary object, I'm going to go right ahead and design the attributes I think each dictionary will need.

It's Name : JEDict
The Language it can translate to : ENG-JAP
The language it can translate from : ENG-JAP
It's own icon

Is there an industry standard for codifying this up?
I should discuss this with Jim this Friday if possible

Words: Milestone. Basic Manual and Smart Grouping System Implemented

2006-08-19T15:47:00.000+10:00

Yaaaaahoooo!

I've integrated subproject Groups into the main pproject Words.

Had one hiccup, and I spent WAY too much time on it before going to google, where I found this apple documentation, right in the Core Data trouble shooting section. I had the intuition to know it was something to do with the Model.

Anyway, I found the following:
-_-_-_-
Cannot create new objects with array controller
Problem: You cannot create new objects using an NSArrayController. For example, when you click the button assigned to the add: action, you get an error similar to the following:
2005-05-05 12:00:)).000 MyApp[1234] *** NSRunLoop

ignoring exception 'Failed to create new object' that raised

during posting of delayed perform with target 123456

and selector 'invokeWithTarget:'

Cause: In your managed object model, you have probably specified a custom class for the entity, but you have not implemented the class.
Remedy: Implement the custom class, or specify that the entity is represented by NSManagedObject.

-_-_-_-

Which was exactly my problem.
I read it carefully, but already knew what my problem was. Since I had tested and could create Languages and groups if the array controllers managed NSManagedObjects, I could tell there was something up with the custom classes. They weren't being included in the target or something... turns out I wasn't even COMPILING them. So of course I was getting stupid errors.

Anyway the good news is that it seems to work pretty well. Every thing has slotted together and I can import lots of words at once, and see them in my library, and divvey them up in manual groups and.

Standby for some delicious screenshots :-)

This is a screen with a perfectly pedestrian list of words containted within the manual group called "Word of the Day".

And by setting a simple predicate to the smartgroup, we can automagically specify whichever words we want to see!

Still left to do is write my weekly reports, which the blog should make relatively painless, but that still is something that remains to be seen.

I am going to try out use case, test driven development as a means to creating healthier code which breaks less, and when it does, I know why.

There are still things to implement with regard to smart groups. Right now it's hard to tell which is smart and which is dumb in the list, so it would be nice to have an icon. It would also be sweet if the list was ordered nicely. But that's all UI stuff. The model works! The model works! Yippeee!!

Uh, of course I KNEW it would word, just for the record :D

Is Done, Is Groups

2006-08-17T15:07:00.000+10:00

Right now the SmartGroups object is trying to do some optimisation schwisseling to determine whether things need updating or not.

It works by setting wordSet to nil if the refresh function determines that the wordset needs updating, if it doesn't then it leaves the current wordset attached to the wordSet variable, and the 'words' function that is called by the bindings is simply returned this old, unrefreshed set.

What seems to be happening in my program is that the refresh function isn't setting wordSet to an appropriate setting.

Ok, so there are a few issues with the groups system. Adding words aren't updating themselves without a restart, which is pretty bad, considering delete works. For some reason they won't fetch. But I am sick of trying to find out why for the moment. So I'm going to leave it and move on.

I seem to be able to type predicates into the predicate box, and they set themselves fine, and the view resets itself to show a nice list of the words that match the predicate in that language.

Features associated with this system that I would like to implement are
1) Drag and drop from manual group to manual group, which adds the receiving manual group object to the set of manualGroups that the word object maintains.

2)User Friendly, graphical user interface for the predicate editor. This would only be able to be built after the groups sub project is incorporated into the main project.
This is because the predicates would have to be set to a more diverse set of object attributes than in the example. It's only once you have interesting meta data that predicates can really show their power.

Along the way i have had some issues with the SVN repository. I have made several project ressurective rollbacks, so I greatly value and ,make use of it's benifits, but I still have some way to go before I can use it seamlessly.

The next task before me is to incorporate the groups sub project into the words project.
I don't think it really makes sense to import it as a framework, because the code is pretty application specific, and while the underlying idea beneath it is useable, I don't think it warrants factoring it out as a framework.

Grroooooooooups

2006-08-16T16:24:00.000+10:00

Languages will be set via the preferences menu, where the user can set the various settings for the language.

I need to be able to set the predicate to find WORDS that have their language relationship set to

language.name LIKE[c] "English"

language.name like[c] 'Japanese' AND word like[c] 'テスト*'

Will give me a nice smart list of all the words in my Japanese language that have テスト and anything after that (wildcard *).

I'm thinking that if I hard code the first part of the predicate into all smart groups then this would be better design.

So when a smart group is created, it is automatically bound to that language.

If all Language editing is done via the preferences menu, then we might have a model in which to implement this.

Ultimately, what we want to be able to do is simply tell a smart group via a predicate what to display, and have it do that. It's not going to do it automatically (the setting of it) but once it knows what it needs to display, then it's up to us to keep on displaying it without error.

I just committed to SVN probably the most stable version of the system yet.

Weekly Review: 08-13

2006-08-13T13:53:00.000+10:00

- Continued development of the smart group system.
- Specified more requirements for the grouping system.
- Achieved a milestone implementation of 'the most stable' group system yet.
- Completed the group system, understanding exactly how the Apple sample code worked, and accepting some faults of the system as implemented, because of the constraints of time.
- Documented the features that still need to be implemented.
- Completed the integration of groups into the main words project.
- Words can be seen in manual and smart groups in the main window, and the predicate for the smart groups can be set manually.
- Decided to try to begin use case driven development.

WWDC Day 2

2006-08-10T07:49:00.000+10:00

Waking refreshed at 7 am, I took the window opportunity for exercise. The treadmills downstairs were all in use and the only working one was out of order, but that turned out to be a blessing in disguise, because I ended up jogging right out of the building onto the streets, down 2nd St, Past Market St, then up a steep San Francisco hill all the way to the top, where I got near 360 degree views of the city and bay. The bay bridge was silhouetted against the glaring water with the morning sun, and looking south I could just see the Golden Gate bridge (my first glimpse) and Alcatraz in the distance.

Yesterday was a conference day, and the highlights were lunch, and the break between the session! Let me explain - I chose a random table at lunch, and after a while I said hello to everyone and found that one guy worked at Apple. On what team? I ask, "The Finder team" he tells me. So I proceed to tell him about my finder issue, which everyone has been saying is reallllly strange.

He poked around in the terminal, examining the setup and even the dock preferences, but he actually couldn't find the problem, right there at lunch. But it was neat to have the finder guy explaining it to me, even if the problem itself was out of his ability to fix immediately.

Even greater was when I went to the OS X lab to ask about my smart list problem, and finding a guys name under 'Core Data' on the white board I explained what I was doing and he told me that in fact he was just doing smart lists in core data that morning, and flipped open his laptop and there it was right on his screen. It actually was similar to my solution. I showed him my code and he said it all looked fine.

It was really great to know that something I had been going it alone with was turning out to be in the right direction.

I also got tips on how to solve the rest of the problem, so now I can flesh it out without worrying if it's the wrong thing to do.

Weekly Review: 08-06

2006-08-06T13:59:00.000+10:00

This week I was attending WWDC.
- Worked heavily on grouping system, when I had free time, and the system progressed steadily.
- Had Apple Core data and Cocoa engineers review my system and give advice, and also help find bugs.
- Learnt about many other Apple technologies that apply to Words and other software I plan to develop.

Web Software Vs Desktop

2006-08-03T15:29:00.000+10:00

Just a thouht I had in the shower a couple of days ago...

All this debate over whether the future of software is on the web or on the desktop or whatever.... I believe the answer is that it's going to be on both. Because software designers need to step back and realise that it's not about software, it's about user information, and they also need to reassess their view of software to match something more like their views of hardware - generic boxes that house stuff. The attitude should be that software will be a generic housing too, for the really valuable stuff - people's information, and that information should be managed wherever the user is, whether it be on the web or desktop. Integrated and synchronised seamlessly, access to information should happen on whichever box, and whichever software.

I think the two will coexist too, one won't push out the other.

What is words ere networked software and people started to use it to develop their own languages? And kids started to build their own in group talk.

Also words should have some mechanism for adding lists of words with their definitions from people's existing lists.

And some kind of quixksilver-esque way of quickly adding and defining words.

Groups: Smart Groups V1

2006-08-02T00:24:00.000+10:00

Now that I'm moving on to developing the smart group system, I have to think about how users are going to edit the predicates.
I have to first of all
a) learn about predicates myself
b) Implement it stupidly so that the user has to know something about them as well.
c) implement or insert some kind of prefabricated UI predicate editor which sets the smart list predicates depending on word data.

Let's start with the library.

When a language is created, a smart list called 'library' is also created.
A new word 'Welcome' is associated to the new language.
When the word array is updated by the groupController with the Library smart list selected, it will fetch all words and plop the resulting array into the word array.

Then we should be done.

Hard code the library predicate into the library object, and don't allow users to change it.

I used the smartgroup code from CoreRecipes and it built me first go a class which provides me with a nice accessor method - (NSSet *) words; which will do all the hard work and give me a set to put wherever I like for all the words that are in the smart group. I can also use a similar interface method to set the predicate too.

Might have screwed up something with my manual groups though... some objects aren't lasting! :-(

Anyway it's time for bed.

Groups... Almost there... Promise!

2006-08-01T12:41:00.000+10:00

Groups
The sets aren't persisting.... actually, they were! I just wasn't telling my code that a ManualGroup was a manualGroup, and the program was skipping right over the display update code.

Nice to use the debugger to fix this and then find some old word objects I thought I had lost forever attached to some old manual groups :)

Another bug to iron out.

2006-08-01 11:59:09.912 Groups[10213] Filling the word array with words from this manual group
2006-08-01 11:59:10.091 Groups[10213] Exception raised during posting of notification. Ignored. exception: Cannot perform operation without a managed object context

Who is calling this. WHAT doesn't have access to a moc?
Do we ever really know how what we've created works?

Anyway, it seems my update isn't working properly, But it looks as though objects are being added properly and managed in the right way. My MODEL is correct, but my methods for the VIEW is still struggling somewhat.

Hmm. I know.

WELL GET A MANAGED OBJECT CONTEXT!!!!!!

I've got word objects associating themselves to manual groups, and being managed by their selection.
They stay in the application from launch to launch (they persist) and all is well and dandy.

Moving right along.

It was ASKING for a managedObjectContext, so I gave it one, right within interface builder :D
Seems to update itself with each click now. Will it persist....? Hey hey hey!!! It all works.

All shiny and sparky...

Manuaaaaaal Groups!!!!

Words Specification V2

2006-07-31T23:03:00.000+10:00

Just finished V2 of this document for the sake of formalising what I want to achieve in the final project this semester.
You can read it in PDF format. It will be there as long as I am a Monash Student (it's hosted on their server).

Weekly Review: 07-30

2006-07-30T14:11:00.000+10:00

-Completed Words Specification Version 2.0, which is a stripped version of the original document which was unnecessarily lengthy.
-Continued work on Groups, mistakenly believing that I was almost done with it.
-Effectively used the debugger to find errors in my code.
-Added a Managed Object Context in Interface Builder which eventually turned out to be in error, but solved a problem at the time.
-Manual grouping system worked with word objects persisting in the store.
-Identified the challenges and things I would need to know about to implement smart groups.
-While attempting implementation of smart groups broke manual groups, indicating that perhaps the design is not as modular as might be desirable.
-Had an 'ideas day' where several new and high level feature ideas for Words came about.

Back to Specs and UI

2006-07-29T15:23:00.000+10:00

It's interesting the swing I've made from spending a heap of time on
UI, to wanting to always get back to the implementation side. It's
probably because before, UI design is all that I really knew how to
do! It's a bit of a mind flip to get back to thinking about UI, and
actually caring about UI.

I had a meeting with Jim Breen yesterday and he said he needed a sure
and fast specifications document, so I'm fleshing it out at the
moment. Mostly rewriting everything really, although I thought I
would be able to rehash the dated stuff. But I need screen shots
now... so off I go!

Words as my Final Year Project

2006-07-28T14:38:00.000+10:00

It's all happening! Here's the Monash project list for second semester, with my own one right in there, and here is the project news site.

Groups! Oh Groups!

2006-07-28T13:10:00.000+10:00

My job is to teach the groupController to chuck word objects into the arrayController.

This involves teaching the SmartGroup and ManualGroup entities how to store or fetch certain words, so THEY can tell the groupController that 'I look at these word objects'.

Thank-you Justin! I think you may have solved my problem. Justin Anderson
http://www.tensaimac.com/

I'm getting a proxyObject which, while is keyValueCoding Compliant, will not allow me to use the full functionality of the object.
I need to grab the actual object with
[[controller selectedObjects] objectAtIndex:0]

Ok, so I'm probably adding words to manual groups now, and setting their relationship, it's just that I can't see them!

But from the way it's looking and working at the moment, I think I have finally built a structure that will work.
It's a bit finneky though, and I worry about scalability. But let's work for a proof of concept first.

[]On program launch, update the group view
[]Remove the update button, it is no longer needed.
[]set the first 'language' word to be 'welcome'
[]It is adding a new word each time I click update. Stop that.

My database class is going to help with my data modelling too, since it is teaching me sound database concepts that I'm just faffing through at the moment. It's really really boring, but so powerful and important for data storage. Somehow I've got to make data storage exciting... ;-/

Anyway, back on the bus, I think it's safe to say that NSArrayController doesn't have any delegates, so I should probably try to stop checking, and just get on with connecting things up with outlets.

Fri 28th July
Groups! Oh Groups!

I had been getting a bit emotional about the fact that I couldn't get groups to work. But somehow I've managed to get something like it working. Admittedly the groups don't manage any words yet, but I think I'm well on my way to having that work.
The view is updated each time the language changes to reflect the groups that are associated with that language. You can create and delete the different types of groups.
The next thing to do is to
[]Order the groups by type, with the special 'library' smartgroup at the top.
[]Remove groups o

Project Description

2006-07-26T12:00:00.000+10:00

Project Title: Words - Computer Aided Vocabulary Management for Language Learning.

Learning languages often involves a certain amount of raw vocabulary learning, and the student can often spend much time managing stacks of flash cards, lists of words 'to learn', creating these cards and lists, and looking up definitions for words in dictionaries. The end result is a system which is sluggish and boring for the student, and implementing techniques such as the Sebastian Leitner learning method difficult enough not to bother.
Words will aim to implement a systematic, but flexible, and importantly *usable* system for the user to manage a complete cycle of vocabulary learning for whichever language the student is studying. It will manage the process right from when the user encounters a new word, through its definition and learning (using various techniques, ie quizzing) and revision.

Words: Groups: Kinda working.

2006-07-25T21:02:00.000+10:00

Well, not working, but it is something at least.

When I click the update button, the aggregation of the manual and smart lists go in the same table view. Now to actually get them managing word entities...

Here's today's thinking that led to this discovery....

What I might be mistakenly doing is creating a data entity for something that is actually a controller object. Am I storing something that in fact does not need to be stored? After all, it merely presents the aggregated values of two other entities, and this can be loaded when the program is run. The entity itself doesn't and shouldn't store anything to itself, it should only reflect what is stored elsewhere. Indeed, it is a controller object. So I shouldn't really have one in my data model at all.

TableView
NSObjectController GroupCoordinatorController
Enitity GroupCoordinator

I guess that is what I am making, a controller controller in a sense. So the cascading call is normal.

What a mess.

Had a walk at lunch time and decided this:

Anyway I've decided that the groups controller object need not be persisting anywhere at all. It's just an object to churn out an aggregated list of two different types of group objects so that a tableView can display them. It also keeps track of what is selected in the table view, and pops the selected group, whatever it is, into an ManagedObjectController object that is accessed by the word array controller for it's content set.

This is gold.

I actually did this yesterday, but it reflects what I'm doing:

Groups: A New Sub Project

2006-07-24T21:15:00.000+10:00

(Sorry about all the blogging these past few days, I've just been rather active!)
New Project: Groups
I'm starting a new sub development app for Words called Groups in light of what I discussed in my last post.
This would also reduce the run / execute cycle too.

Data modelling. Here's what I propose.
Group is an object that an application can have many of, but a language can only have one group object associated with it.
A group object can have many ManualGroups associated to it, and many smart groups associated to it.
A language can have many words associated to it.
A ManualGroup maintains a list of words that are 'in it'
A SmartList maintains a fetch predicate of words that are 'in it'.

Group, ManualGroup and SmartGroup will be managed by NSManagedObject subclasses which will prove the functionality. The model simply shows who owns what.

Should also create the 'library' smart group programatically at first instance too.

When you 'add' a new group, whether it be a smart or manual, you have to set it's association to the currently selected language's group object.

All these entities will need to be managed with some controlling arrays. That's essentially what they are.

I have set up a groupObjectController in IB to hold whichever instance of Group is active.

I'm getting a bit lost.

Ok.

When you create a new language object, it needs to create a
1. Group object for itself
2. A library smartyPantsGroup object for itself too.
3. Any other default smart groups.
4. The word welcome as the language's new word.

So let's start from there. Subclassing Language to get a feel for what it needs to do, and cascading from there we'll need additional objects and methods which will force us to subclass the other entities in the model.

Heyheyhey! I just discovered a powerpoint in my makeshift Mac Lab with my toe as I stretched! Hooray.

I'm now wrestling with this idea of what the GroupController should be called, because I'm not sure exactly how it will function.
The groupController has to present to the UI a list of all the manual and smart groups that are associated with the Group object that it is controlling. It's an array, but it's probably not ...

When the user clicks addSmartGroup, the message is going to be sent to the groupController, which will
1. Create a new instance of the SmartGroupEntity.
2. Associate this newSmartGroup to itself (toManyRelationship).
3. Somehow show the user a representation of this newSmartGroup in the group list.
4. Set the wordArrayController to answer to the newSmartGroup.

Or am I using the entirely incorrect structre?
Should I, like the CoreRecipes example, make it so that
- Languages can have many group objects, which are managed by a regular NSArrayController
- But a group object can be either a smartgroup or a manualgroup. We don't care which.

Might I create a branch of my new groups project and do this.

Groups is now an abstract entity, whenever you go to create one of these, you actually create a smartList or a ...

damn. Now I just thought of another stucture!

What about if languages themselves can have many smart lists and manual lists, and then I have a subclassed NSArrayController that simply pushes these around?
--
I got three-thirty-itis around 3.30 and went home... I might have another crack at it later.

Thinking... Groups Again

2006-07-23T18:47:00.000+10:00

I would really like my groups and listing system working a bit better. I mean at all.
The wordsArrayController must answer to some as yet undefined 'groupArrayController' object that coordinates what is going to go in the main words array. What it displays depends on
1. Which language is selected
2. Which group is selected.

It needs to maintain an array of two different kinds of objects.
SmartGroup objects and ManualGroup objects. It presents to a tableview the smartGroup objects that are in the system at the moment. These entities are managed by Core Data. An application can have many ManualGroups and many SmartGroups, but only one groupArrayController. What set of groups go in the array controller depends on the currently selected language.

GroupArrayController
|S|M|S|S|M|M| | | | | <<<<<<<<<< LanguageArrayController
.
.
SmartGroup

Here's what it's likely to look and work like:

View GroupTableView
.
.
Control GroupArrayController (subclass to add arrays of smart and manual groups and aggregate them)
. .
. .
Model SmartGroups ManualGroups

Using the (reasonable) success of the Lookup sub project, maybe it's best to develop this system independently of Words and then import it? The controller will contain all of the custom code though.

Words: Milestone: Automatic Word Lookup (from dict protocol dictionaries)

2006-07-23T18:32:00.000+10:00

modify the DictProtocolDictionary class so that handle Definition entities instead of instances of the custom Definition class.
The define method should return an array of these instead of the other types of objects.

MEMORY! Ugh. I was releasing autoreleased objects again. And you think you're doing the right thing! Yuck.

Anyway it's been a bit of a struggle so I haven't been taking notes today, but I've developed what you can see in the following screen shot.

What I think I need next is a 'isConnected' checker method that the system can ask about the network status from where ever.

I'm also going to have to program it to flatted the returned definitions down into a more readable format.
1. See what a variety of dictionaries return in the command line
2. Try removing the \n from the responses.
3. See what it looks like in a tableview

I might have to make a subclass of the tableView to enable more than one line to be visible in a cell. In this way the user will be able to read a few lines of text of the definition.

Also the next step is to start using words for English, French and Italian. I have to start learning some languages!

Here's what the French dictionary responds with:

today t…ôdei] aujourd'hui
English returns

exculpate v : pronounce not guilty of criminal charges; "The suspect was cleared of the murder charges" [syn: {acquit}, {assoil},
{clear}, {discharge}, {exonerate}] [ant: {convict}]

Exculpate \Ex*cul"pate\, v. t. [imp. & p. p. {Exculpated}, p.
pr. & vb. n.. {Exculpating} (?).] [L. ex out + culpatus, p.
p. of culpare to find fault with, to blame, culpa fault. See
{Culpable}.]
To clear from alleged fault or guilt; to prove to be
guiltless; to relieve of blame; to acquit.
[1913 Webster]

He exculpated himself from being the author of the
heroic epistle. --Mason.
[1913 Webster]

I exculpate him further for his writing against me.
--Milman.

Syn: To exonerate; absolve; clear; acquit; excuse; vindicate;
justify.
[1913 Webster]

It would be nice if the dict protocol was more XMLey and tagged metadata to the results returned. Parsing is going to be a bitch because all dictionaries seems to abide by their own format.
Ah. See this http://xdxf.revdanica.com/

This might be the next 'type' or 'protocol' of dictionary that I could support.

Maybe developing dictionary 'packs' are in order. A plugin architecture so that parsers for various specific (and popular) dictionaries can be added and then made to work with Words nicely.

Weekly Review: 07-23

2006-07-23T14:37:00.000+10:00

-Reached a milestone for words by implementing lookup for words in dict protocol dictionaries.
-Learnt first hand the perils of incorrect memory management in Cocoa Objective-C.
-Identified limitations and features that need to be implemented beyond the basics that I have working.
-Realised yet again that I should be using the software day to day in order to determine which features are most crucial to the software.
-Found a project which is trying to bring XML to the dict protocol, something which would be desirable in words.
-Considered supporting the protocol in the future.
-Began thinking again about a more advanced grouping system for Words, and laying out an initial design, and conceiving of a proposed framework for the system.
-Started a new sub project separate from the Words project called “Groups” in which to implement the grouping system in isolation.
-Reached a 'kind of working' state for groups, where smart and manual groups were displayed in the same window.
-Jubilantly discovered a power outlet in the spot in building 75 where I'd been lurking for the past few days.
-Doubted myself for diverting from the sample code provided by Apple for implementing smart groups with Core data, as I felt it was convoluted and that there “must be a simpler way”. (It turned out after speaking with the Core Data engineers that this was perfectly fine).
-Wrote the project description for the subject web page, and the project is made officially my final year Project
-Made use of online mailing list forums to solve issues successfully.
-Gained confidence that the group framework I was building was one that will work, although I worried about scalability.
-The ugly emotional side of software development reared its head this week, and I steel myself against times in the future when things just don't work and loose confidence.
-Began Version 2 of Words specification document.
-Noted change from previous heavy UI design to 'under the hood' implementation, back to UI again for the specification document.

Words: Merging Lookup and Words

2006-07-22T23:25:00.000+10:00

Ok, I'm going to try and merge the two projects so that I can automatically search for word definitions when I add them.

I've just realised I can hand the management of dictionaries to core data. This way they'll persist.

This isn't turning out to be as easy as I would have liked. So there are going to have to be some minor changes to the model and the controller. I've subclassed NSArrayController to DictionariesArrayController which takes care of the UI outlets and actions, and automatically prepares CD Dictionary entities. The only action to far is 'connect' which will be invoked when the user has entered dictionary details. It will create a new entitiy with the appropriate relationship to whichever language is selected, and plop the data that must persist between launches of the application into the entity (server, database, username, password). Then it should invoke the dictProtocolDictionary's own awakeFromInsert method which will then make the actual connection. In this way, when dictionaries are loaded at launch time into the array, they can reconnect to their servers and be ready to define words.

I've got a problem: The NSArrayController seems to only want to handle objects of one type. Why is this so? Surely I should be able to string up any kind of object I like in it. addObject:object kind of situation.
Maybe it's bindings that's restricting me. The tableview needs to know what to display. But I've told the arrayController that it's got to manage entities of type Dictionary, which is an abstract class. Which means that you can't actually make of these objects, to do so is useless! It's actually the same problem I've had with trying to get smart lists and manual lists in the same view. What if the array controller managed two separate arraycontrollers, then then pulled the two together into the same array? That would be a bit messy methinks.

I possibly don't need to have core data manage the Dictionary entity as such. I mean, if I never actually have an instance of one, then why does core data need to know? Entity DictProtocolDictionary can still have a relationship with Language, so that dictionaries of that type can know to whom they belong. The subclass behaviour can come from the manual hardcoding of the entities classes. The ArrayController can directly manage dictProtocolDictionaries for now.

Here's what the connect button in the controller object should do, as far as I can see so far.
- (IBAction)connect:(id)sender
{
//create a new DictProtocolDictionary in the moc
//create a new dictionary entity and populate it's data.
//add it to the array
//(this should invoke the entity's awake from insert method which will make the actual connection)
//once you're connected and there were no errors, clear the UI, ready for the next connection

}

Actually, awakeFromInsert isn't entirely appropriate. Because it isn't called when the object is being recalled from the moc. What we need is something that will go through the dictionaries in the system and connect them when they are summoned out of the moc.
awakeFromFetch is more appropriate! (For reconnecting).

So now I am able to create and delete persisting dictProtocolDictionaries in Words proper, which associate themselves to languages. The next thing to do is to make sure they are connected not only when they are fetched by the window, but at launch time too, so that they are connected and available even when the dictionary pane hasn't been opened yet (can work around this for a while).
Each time a word is entered, the applicationController should try to find definitions for it. Words that have been defined are checked off as having been done so. This is so that later on the application can go though and find undefined words and define them.

Still more work before I can call a milestone with a screenshot ;-)

Nothing Much New Today

2006-07-19T20:54:00.000+10:00

Ok, so I've got words (lookup) connecting to any dict protocol dictionary in the world, but I still have plenty of issues to address.

The results being returned are themselves hard to read in a table view. It may be necessary to parse them into one line, so that at least the first few words can be read.

Right now when people walk away from the internet, they have gone from having plenty of dictionaries, to having none.

Also, as words are added enmasse, the dictionary lookup service adds things to the array one by one, but the user interface isn't updated until the very last definition has been found. It would be nice to add each as they are found.. but having thought about that the dict protocol returns one struct for each query containing all things found as it is, so it wouldn't work that way definition by definition, but it could work for word by word, and it will work this way without any modification.

In the dictionaries preferences pane, whether the dictionary is available online or offline should be indicated. Users should be able to specify the name, and kind of dictionary, and if needed specify the location, whether it be server or local file.

There should be some indication of what is being done in the user interface. A spiral progress indicator should be spun while the definitions are being hunted down.

Kind of need to write up my application to do this as final year project.

Submitted the application today. I'm pretty tired tonight so might take a rest from Cocoa until tomorrow.

Words: Milestone Automatic Word lookup in Multiple Dict Protocol Dicts and Databases

2006-07-18T22:31:00.000+10:00

More notes that I took while thinking through today's developments...

I'm going to create a new interface to the UI AND to the class that will allow me to initialise a new dict Protocol object. It will then be available to the user to query while the program is running, and the results will be displayed on the right.

Hmmm

But how is this going to help words?

Within the Words system, whenever there are
1. Undefined words
2. A suitable dictionary available wither locally or remotely

it should try to automatically find definitions for each undefined words.

Fetch from the ManagedObjectContext all instances of the Word entity that have not been defined.
Order them in some way (or not). Importance??
Start from the top of the list and go to the bottom. For each Word object in the array.
[Dictionary define:word]
Place the definition

But I'm getting such varied quantities back from the dictionary. And that's only from the one server, in one database! What about when the possible servers and databases increases!?
The exact results are unpredictable, but they will be within reason. And we know how to handle definition objects well enough. Generally, the first few results fired back from the dictionary are the most relevant.
However, we cannot safely disregard the other definitions.
If the default is inappropriate, then the user must decide which definition they want to be 'Number 1', and promote it to the top of the definitions list. This is the definition that is used for quizzing, word lists etc, however, the alternative definitions are still available.

In the UI, all definitions will be available via an auxiliary window. The main definition will of course be viewable against the original word.

I could probably go right ahead and put the DictProtocolDictionary class right into my existing words prototype, but I want to make sure it is ready and will be able to do everything that I want it to do. But I suppose I can always add to it and modify its behaviour later.

What I think I need to workout next is the UI for this system. Words now has the ability to connect to any server that implements the dict protocol. How is the user going to
1. Create a new dictionary.
2. Specify which dictionary they want to use.
3. Remove Dictionaries.

I also have to make sure there is an internet connection available when the dictionary tries to connect, and to fail gracefully when there isn't (rather than crashing which is what lookup does at the moment!)

Possibly, the user can set any number of dictionaries themselves (or select a suggestion from the list) which then associates itself to the actively selected language.
The special case is that it's not a foreign language to you, in which case you are looking for only definitions, not translations to words. There might be a checkbox to allow the user to specify whether the dictionary is going to be used as translation or a definition dictionary.

I just sketched a preference pane which allows you to choose language, add and remove available dictionaries, check whether they are active or not, a text field to change the server and database, and below that the other dictionary settings.

The application will take from these available dictionaries their definitions.

Therefore dict class should have Cocoa compliant Getters and Setters so I can hook them up to an IB GUI.

Before I set up preferences and the like in Words proper, I need to make sure that the classes can handle all the setters and options etc within the cocoa environment. Can I create more than one dictProtocol dictionary and change it's database etc dynamically. This should be developed in the Lookup application.

Aaand here's the fruits of today's labours. What fun! I can't wait to make it easy for anyone to connect to any dictionary in the world with such a simple interface.

(Click) and look! It's translated cheese to fromage!

Of course, the end goal is to hook the above with what is in this image:

Use the services menu to add you existing word lists (or just a single word) to Words, and have it find the meaning for you, and then save it for later.

fyi

THESE are the dictionaries that reside on dict.org alone!

Database list:
gcide
        The Collaborative International Dictionary of English v.0.48
wn
        WordNet (r) 2.0
moby-thes
        Moby Thesaurus II by Grady Ward, 1.0
elements
        Elements database 20001107
vera
        Virtual Entity of Relevant Acronyms (Version 1.9, June 2002)
jargon
        Jargon File (4.3.1, 29 Jun 2001)
foldoc
        The Free On-line Dictionary of Computing (27 SEP 03)
easton
        Easton's 1897 Bible Dictionary
hitchcock
        Hitchcock's Bible Names Dictionary (late 1800's)
bouvier
        Bouvier's Law Dictionary, Revised 6th Ed (1856)
devils
        THE DEVIL'S DICTIONARY ((C)1911 Released April 15 1993)
world02
        CIA World Factbook 2002
gazetteer
        U.S. Gazetteer (1990)
gaz-county
        U.S. Gazetteer Counties (2000)
gaz-place
        U.S. Gazetteer Places (2000)
gaz-zip
        U.S. Gazetteer Zip Code Tabulation Areas (2000)
--exit--
        Stop default search here.
afr-deu
        Africaan-German Freedict dictionary
afr-eng
        Africaan-English Freedict Dictionary
ara-eng
        English-Arabic Freedict Dictionary
cro-eng
        Croatian-English Freedict Dictionary
cze-eng
        Czech-English Freedict dictionary
dan-eng
        Danish-English Freedict dictionary
deu-eng
        German-English Freedict dictionary
deu-fra
        German-French Freedict dictionary
deu-ita
        German-Italian Freedict dictionary
deu-nld
        German-Nederland Freedict dictionary
deu-por
        German-Portugese Freedict dictionary
eng-afr
        English-Africaan Freedict Dictionary
eng-ara
        English-Arabic FreeDict Dictionary
eng-cro
        English-Croatian Freedict Dictionary
eng-cze
        English-Czech fdicts/FreeDict Dictionary
eng-deu
        English-German Freedict dictionary
eng-fra
        English-French Freedict Dictionary
eng-hin
        English-Hindi Freedict Dictionary
eng-hun
        English-Hungarian Freedict Dictionary
eng-iri
        English-Irish Freedict dictionary
eng-ita
        English-Italian Freedict dictionary
eng-lat
        English-Latin Freedict dictionary
eng-nld
        English-Netherlands Freedict dictionary
eng-por
        English-Portugese Freedict dictionary
eng-rom
        English-Romanian FreeDict dictionary
eng-rus
        English-Russian Freedict dictionary
eng-spa
        English-Spanish Freedict dictionary
eng-swa
        English-Swahili xFried/FreeDict Dictionary
eng-swe
        English-Swedish Freedict dictionary
eng-tur
        English-Turkish FreeDict Dictionary
eng-wel
        English-Welsh Freedict dictionary
fra-deu
        French-German Freedict dictionary
fra-eng
        French-English Freedict dictionary
fra-nld
        French-Nederlands Freedict dictionary
hin-eng
        English-Hindi Freedict Dictionary [reverse index]
hun-eng
        Hungarian-English FreeDict Dictionary
iri-eng
        Irish-English Freedict dictionary
ita-deu
        Italian-German Freedict dictionary
jpn-deu
        Japanese-German Freedict dictionary
kha-deu
        Khasi-German FreeDict Dictionary
lat-deu
        Latin-German Freedict dictionary
lat-eng
        Latin-English Freedict dictionary
nld-deu
        Nederlands-German Freedict dictionary
nld-eng
        Nederlands-English Freedict dictionary
nld-fra
        Nederlands-French Freedict dictionary
por-deu
        Portugese-German Freedict dictionary
por-eng
        Portugese-English Freedict dictionary
sco-deu
        Scottish-German Freedict dictionary
scr-eng
        Serbo-Croat-English Freedict dictionary
slo-eng
        Slovenian-English Freedict dictionary
spa-eng
        Spanish-English Freedict dictionary
swa-eng
        Swahili-English xFried/FreeDict Dictionary
swe-eng
        Swedish-English Freedict dictionary
tur-deu
        Turkish-German Freedict dictionary
tur-eng
        Turkish-English Freedict dictionary
english
        English Monolingual Dictionaries
trans
        Translating Dictionaries
all
        All Dictionaries (English-Only and Translating)
web1913
        Webster's Revised Unabridged Dictionary (1913)
world95
        The CIA World Factbook (1995)

Words: Milestone. Dict Protocol Word Lookup

2006-07-17T22:43:00.000+10:00

After yesterday's productivity, today has seemed rather disappointing. What I have to remember is that even though I might not get on screen progress done, what I'm learning from my mistakes will help me program better in the future.

For example, I've learnt one lesson today - the less C++ there is my life that happier I think I'll be!

You see, there's this free program to access dict protocol compatible servers written in C, and there was a convenient wrapper to it written in C++. I tried to link it into my Lookup app, but it threw nasty errors at me for hours. Maybe I don't know the mechanics of it yet, and there is a simple way to do it. Anyway I realised that the C++ wrapper around the C code was actually what I should probably be rewriting for my own app in Objective-C.

Many hours, castings, photographs with Lord Mayor John So later...
@ 10.19pm

Bingo!

Another milestone! I now have my DictProtocolDictionary instance importing definitions right into the object from somewhere in Alaska I believe. Should only be short work to extract the data from the struct it's currently residing in, and plop it into the definitions array controller to be shown in the table view.

Done! Of course it's not perfect. There are multiple rows displayed in the table, and I'm going to have to parse the definitions for those that are meaningful, and take out things like procunciation, and word type in some handy variables. And give the dictionary server and dictionary database itself credit for the service.

Next I think I should create an interface which allows the user to specify which dict server and which dictionary on that server they wish to query.

Actually there still is some work to be done with the DictProtocolDictionary class. I haven't implemented all of the code that the C++ wrapper did that I was wrangling with on the tram this morning.

All this stuff is really starting to make sense now, and I'm loving it! You come across something tricky and you apply yourself for a few minutes, debug, think some more, realise something, then come up with something beautiful like this:

Definition *newDefinition = [[Definition alloc] initWith:[NSString stringWithCString:(theDefinition[idx]->ld_answord)] andDefinition:[NSString stringWithCString:(theDefinition[idx]->ld_ansdef)]];

Mwah! Bellissimo!

I start back at Uni tomorrow, and with any luck something from this blog will become my final year project and I will be able to spend even more time developing.

Words: Lookup

2006-07-16T22:32:00.000+10:00

Since I've hit a bit of a wall with smart lists (ideas anyone??), I'm going to put it aside and try to develop in isolation another hairy part of Words. The definition lookup feature.

By isolation I mean that I will start a new project, with a simple UI that is the front end to the lookup class (or classes) that take a word string as an argument, and return 'definition' objects. This is how I envision the system will work.

The following are the notes I took today while thinking and devloping what the screenshot shows below. They don't flow very well!

While I am aiming for language generality, I still believe that there will be language specific things that will need to be handled by a subclass of the generic 'dictionary' object.

LookupUtility has the function "(NSArray *)lookupWord:(NSString *)word inDict:(Dictionary *)dict" which is the interface for whatever needs to lookup a word in whatever dictionary. It returns an array of definition objects for word.

There should only ever be one LookupUtility instance per application.

This diagram shows neither the lookup utility (as I scrapped it in the end) nor a generic 'dict' protocol class (yet to be implemented).

Dictionary is an Abstract Class. The application should create instances of a Dictionary subclass that is applicable to the particular user's needs. Ie, If a user has specified that they are learning Japanese and their native language is English, then the application should instantiate a JapEngDictionary object that can churn out definitions when queried with a string.

The DictProtocolDictionary can be instantiated (not shown in the image), one for each dictionary that can be accessed via the dict protocol. In the user interface, the user might be able to cause this to happen

The user should be able to select which dictionary object the application should use to find definitions to their words by default. The application controller (delegate) should keep check of what dictionary objects are available (a dictionary manager view??). From here a user might be able to select a word and search again in dict:selectedDictionary for example, if they feel they can find better results elsewhere.

So to make the development easier and modularised from the main Words app, I am starting Lookup.xcodeproj (or whatever that filename is these days). With luck, the classes I develop should be able to be imported directly into Words and hooked up to the WordsAppDelegate no problem.

Because Lookup.application doesn't really need to STORE anything, I'll use the Cocoa Application template from within Xcode.

I've created a simple interface in IB, and have created AppController, with an action 'search' and an outlet 'wordToLookup'. Later I will add two NSArrayControllers, which will control the Dictionary and definition objects contained in the NSArrays returned by the dictionary objects. Bindings should take care of the display of this.

First I am going to check that this structure works by creating the classes with stubs that return static example Arrays.

Actually, I've just realised that the AppController doesn't control which dictionaries are available, the NSArrayController called dictionaries does. It can co-ordinate adding and deletion from the model... but in fact we don't want it to be able to do that. We want to do that programatically by asking the Controller nicely if it would please add this new dictionary object we've just created to its trusted care. Then we can autorelease it :-)

Ok, so now I've got some to-be dictionary object in the array.

How I handle these dictionaries has to be separate to how they work.

Later on that night...

I believe I've got the mechanics of it working well. Next step is to test whether its architecture is suitable for scalability. I'll create a new class for a French and English dictionary, and see if I can add it to the list of dictionaries, and ask it for definitions dynamically. Wait a sec... Yahaaa! I had checked 'Automatically Prepares Content' - a throwback to my yesterday Code Data ways. Of course, It's not to automatically prepare any content at all - I'm deciding to do all the work! This also explains the added extra definition object that was being automatically prepared in the Array.

So there I have it, a kind of 'framework' for me to handle multiple languages. A little simplistic, but a proof of concept.

Next is nothing but
1. Adding the code to actually access the dictionary databases (probably messy)
2. Parsing the results into nice rich fields that can go in the definition class / entity.
3. Creating as many Dictionary class subclasses for the dictionary databases that I can find.

And then attaching the whole lot the main Words app and running it all on each word that is input.

---

Brainwave. Have a thesaurus as well so that writers can use Words to search for alternative words, and keep track even of when they have used them.

Weekly Review: 07-16

2006-07-16T20:43:00.000+10:00

- Having difficulty with grouping system, so began work on dictionary management and lookup.
- Started a new, isolated project 'Lookup' to do so.
- Did preliminary design and brainstorming of how the system might work.
- Got the initial structure of the system working, which proved the concept
-Outlay what needed to be done.
- Utilised an open source dict protocol program by writing an Objective-c wrapper around it.
- Linked it to the Lookup project and connected the user interface to define words from dict.org, and display the results in the table view.
-Identified areas that needed improvement

Words: A Conservative Milestone - Manual Lists

2006-07-13T15:20:00.000+10:00

Been a bit quiet here for the past couple of days, been working on implementing groups for Words. I tried to follow the example of Apple's CoreRecipes app, but while I understood what was going on, the implementation directly ported wouldn't have worked with Words. In the recipes app, the highest Entity is the Recipe, whereas in Words, it is Language. Anyway to cut a long story short, I've taken the Mr. Obvious route and used a simple model for groups. I think I should be able to set up smart lists using a fetched property in a SmartList entity without too much hassle, which will fetch 'whatever' (whatever being specified by the user / system) and tell the WordArrayController to display it. Which will also allow me to have a 'fetch all the words in this language' which will be set as default and will be, in fact, the Words equivalent of the iTunes 'Library'.

If I WERE to use the fangled smart list stuff, I thought that a Language Array Controller would then in turn manage which GroupTreeController was active, which would then determine what words were accessable by the WordsArrayController. Anyway maybe that's for a later day when I am feeling more comfortable with Cocoa and Core Data. Right now while I'm essentially prototyping my App I'm going to TELL MYSELF it's OK to take the easy road. For Now. Ok I'm done. No really.

Sigh.

Honestly I really would have rathered I'd gotten the more fancy stuff working.

Here's what we have then:

With this data model

Words Milestone

2006-07-09T22:05:00.000+10:00

Imported my parser class from a previous project that adds words enmasse. Used memory management and arrays to pass around the words from an industrious parser class, and I'm satisfied with the results. Go Cocoa! I was also enjoying thinking about the modularity of the classes and code, and about what consists best design. UI still a mess, so no screenshot ;-)

Weekly Review: 07-09

2006-07-09T14:36:00.000+10:00

- Learnt first hand the advantages of using subversion for revision control.
- Found an old project in my archives that tokenises words. Still needs work done on it though, but it was nice to have such simple code reusability.
-Began experimenting with a grouping system, and decided to go against the example code provided by Apple to do smart groups with Core Data. Was a little disappointed in myself to taking the obvious route, however. Manual group system working.

Subversion

2006-07-09T11:21:00.000+10:00

Setting up subversion for my noodle timer project this morning, I tried adding to the custom class for my managed object. It all went pair shaped, and I decided that I need to read up more on how to do it. Previously, I would have sifted though the code and removed my changes, this time, I simple killed the working folder I made the modifications in, and 'rolled back' to the stable copy by checking out what I had checked in earlier. All worked perfectly. What a system! I saved time and now I am sure nothing has been broken by my own blunders.

Cocoa Workshop Day 3

2006-07-07T16:39:00.000+10:00

Today is about learning how to create a really interactive application. Graphics, archiving. Storing objects in the model and havin the view display them.

Custom view - just a generic view, it doesn't have a class associated with it. You do this via the custom classes attribute. You could assign it to anything, but you make your own!

Quartz Debug (the flashy thing) can show what is being redrawn in your app by quartz. Use it while optimizing.

Event methods
– mouseDown:
– mouseDragged:
– mouseUp:
– mouseMoved:
– mouseEntered:
– mouseExited:
...
All these tell you the events that we can monitor and watch for.

Floating point numbers for pixel referencing makes for antialiasing and blurring of lines. Nice!

Option double click! Wow!

The receiver is always what is on the left hand side of the method call.

Make sure you know which nib file you are working on and that it corresponds to the current Xcode project!

だからこのように自分で設けて、モデルしながらプログラミングする。

Cocoa Workshop Day 2

2006-07-06T16:45:00.000+10:00

Today we learnt about interface builder, actions, outlets, MCV. We had a go at creating a model object for managing Person objects from yesterday. We made a simple address book.

I also finally used SVN. So now I feel more confident with repositories and such, and mwill endeavour to use it in my own projects.

KTV notes
Quicktime kit with the attributed lyrics, with multiple language support.
It would require creating a custom view so that you can overlay the lyrics on the iSight video
[]Download SVNX

Actions are associated with methods, outlets with controls.

In terms of UML, the outlets are the attributes, and the actions are connected to the methods. Think of a class diagram.

Am becoming more confident with the debugger too which is great.
Also about the organisation and structure of the class heirarchies and how to learn more about them in the documentation.

Code completion! Wow!

Core data is good for quickly prototyping something, but there are versioning issues that Apple haven't addressed. Should probably prototype using it, then implement using more traditional methods next.

Access? Isn't that a curse word?

I'll try to add a link to the