Open Source Adventures @open-source-adventures - Tumblr Blog

Week 11: Final Steps

The integration steps that I described in the last post have been completed by both Scott and myself. I have created a functionality for the text entered into the input box to be saved down to a file at any location (currently just the home directory). I have also allowed for the running of a bash script when “Submit” is pressed. Additionally, I have tested against Scott’s code and can confirm that it works on my machine.

However, we have been completely unable to meet with Sam over the weekend (he was traveling). He will be in Philadelphia from the 8th to the 18th so we might try to arrange a meet up with him.

Overall, I’m happy with what we completed, but I don’t think that this project was a good selection for this class. I know that it feels as though a larger project is a good thing, but this project was definitely outside of the scope of this class. Both Scott and I feel as though working on introductory tickets or smaller bits of the code base would have been more useful. Either way, I did enjoy this project and plan to keep picking away at it, at least for a little bit during winter break.

#week 11 #reflections

Week 10: Preparing for Integration

This week I spent preparing for integrating the code that Scott and I have after Thanksgiving break. I have decided to move on from the automake build that I was working on. The research process here is ongoing. I have been unable to get a conclusive answer from IRC and am waiting to hear back form the man who wrote the original template for the automake build that I am using. However, we have decided to continue work on the plug-in and prepare for integration.

In order to integrate our code, I have two basic tasks:

- Save the terminal output down to a file called “output.js” (using a system command such as write)

- Run a shell script when a button is clicked. Scott will be writing the script that will then run his code.

I have written the code for the first category, but I am still trying to find a way so that an individual can save the script wherever they would want instead of the hardcoded location that I currently have the file being saved. The second part of the task is much more difficult, although I do hope to make significant headway this week.

I anticipate getting a lot of work done this weekend since I don’t have much to do. I will be focusing on the tasks that I have outlined above. We have not gotten to touch base with Sam this week - we sent him a few messages but he has not responded. Due to the high level of responsiveness he traditionally has, I am assuming that he is busy or away for the Holidays. I am sure that we will touch base after Thanksgiving.

#week 10 #preparing for integration

Week 9: (Still) Automake

We had a long check in with Sam today and discussed how we’ve been stuck on the make / automake element of the project. I’m quite disappointed with our lack of progress, but this is an area that very few people actually have experience / expertise in. We have diagnosed the issue, however. The command automake is equivalent to typing ./configure && make && make install, but the “&&” break simply means that if the preceding function call exits with a 1 (error), then the subsequent calls will not run. The configure call is ending with an error because the autoconf utility claims that intltoolize is not creating a Makefile.in.in, however, when we independently run checks with intltoolize, then we do receive a Makefile.in.in.

We are not sure what to do at this point. I’m reaching out to the owner of the tutorial which I followed to a) ask him how to remove this error and b) point out that his version checks are extremely outdated.

Sam thinks (and Scott and I agree) that it would be a waste to spend another entire week on Automake, so if we do not get an answer, either from the owner of the tutorial or from IRC, we will revert back to the old (non-automake) way of doing things. I do think that this is a problem that we’ll have to fix before the semester is up though, but we want to get substantive work done this upcoming week.

My plan for this week is two-fold: 1) continue to work on the Automake issue and 2) work with Scott to integrate his (now compiling!) Gjs code into the plug-in. The hardest part of this will be... you guessed correctly.... merging the makefiles!

I hate C.

#week 9 #makefiles #no progress

Week 8: Automake

This week, I spent my time focusing on getting Automake to work. While it “works” right now, it still does not run with the automake command given some of the technicalities of file systems and where the program mounts (some machines do not have permission to place files into the required directory). I also put some additional refining traits onto my console, adding some text buffer functionality and breaking the file into two parts.

An issue that I am having is that I don’t really understand which files are necessary and which are not necessary to actually have in the repository. That is another focus of my research and involves learning a lot about how GIMP language dependencies and C compilation works.

We were not actually able to meet with Sam yet for the week, but we are planning on meeting as soon as possible to have an hour long catch-up meeting in order to plan the architecture. I am a little worried about my progress for this next week. I plan to get automake to 100% work, but after that, there is nothing that I can do until Scott figures out GObject. In order to occupy my time, I might actually contribute to the template for the GIMP plug-in. It’s outdated (dependencies are not up to date) and the makefile is a little incorrect. I will be reaching out to the author this upcoming week.

#week 8 #makefiles

Week 7: Console Complete

I accomplished all of my tasks for this week, which was nice. Below are some screenshots of the console currently and its output. The console is now formatted and any text that you type registers in the plug-in. I ran into very few issues this week - all of the libraries that I’m currently dealing with are very well documented, which is a big relief. We also had our meeting with Sam today (Friday) and everything is on track.

The console is basically complete, and I am waiting for Scott to figure out GObject compilation so that we can start bringing that into the project as well. Since I have nothing more to do on the console immediately, I’m changing track for this week. After chatting with Sam about it, I realized that I have to change the format that the plug-in is in to include an automake facility so that someone can build it automatically. I’ve already started looking into how I can do this, and it seems complicated. I hope to finish this well before Friday.

Additionally, this upcoming week, we are having a longer chat with Sam on Wednesday to plan the rest of the semester. We’re at a turning point right now and want to make sure everything goes off without a hitch. We’re going to be planning how to set up the rest of the plug-in and what exact tasks to accomplish sequentially.

I’m excited for the hack on Friday! Should be very fun and productive.

#week 7 #console complete

Week 6: Segfaulting

This week was very satisfying. I’m finally getting into the groove of coding for GIMP - my personal development environment is getting set up very well and I’m getting much better at debugging my code! We had our meeting with Sam today, and he recommended that we start hanging out on IRC more to get our questions answered. However, he thinks that we are maintaining good place.

This week, Scott and I actually split tasks. I’m working on understanding Gtk Widgets and getting the console box set up while Scott is understanding GObject and coming up with a framework / plan for the rest of the semester. We were both very successful this week. After what felt like thousands of segfaults, I finally was able to get a text box to pop up. I know this seems like a minuscule amount of effort, but this was actually a complete refactoring of the code we had up until now and I’m very proud of our efforts.

The next step for me, something that I hope to have completed by Tuesday’s midterm presentations, is to be able to collect the text that is typed into the scripting interface and manipulate that in some way (by printing it to the console, etc). This will be a huge step and then we will be able to focus exclusively on the bindings.

Another thing that I want to get started is reading more of the documentation for actually using Script-Fu and PyGimp. Once we have developed our entire scripting interface, we will have to document it extensively, which will be a challenge. However, it’s one that I’m looking forward to.

Next week: read incoming data from console, male the appearance more consistent with Script-Fu / PyGimp. Start reading documentation and planning the bindings. Most likely roadblocks will be in understanding the GTK text buffer interface.

#week 6 #screenshot #console

Week 5: Real Work!

This week was successful, even though it was pretty short (we only started working on Thursday, after the CIS 380 project). The big hold back on making progress this week was the 380 project, but we should be able to make up work this upcoming week. We have created a plug-in that loads and opens a pop-up box.

This is a huge accomplishment for us and we are really excited to be moving forward from here. I also did a lot of research and found a few libraries that will help me with my next big task: creating a dialog box with a text console that will allow user to enter in the script. This is in the same fashion of the other scripting languages on GIMP - Scheme and Python.

We had our meeting with Sam today (Sunday) and he agreed that this was a good way to divide the work. He also gave us some tips and told us to make improvements to the project feature by feature. Additionally, next week we will start to discuss testing and automatic builds.

I am very excited for next week, especially since we are making consistent code progress in our project now. The thing that will hold us back the most at this point is gaps in feedback from IRC / the listserv since I have noticed that it’s not always really easy to get quick feedback.

#week 4 #plug-in pop up

Week 4: Continuing Research

This week was generally successful! We met with our mentor Sam on Monday and spent an hour trying to figure out the bigs that I mentioned in last week’s blog post. We were able to figure out all of the issues with the plug-in creation; there were some missing paths in the libraries that we were using. These types of errors are very hard to diagnose without external help because they fail “silently” without any sort of messages. Luckily that’s what IRC is for :) I will post photos of the registered plug-ins tomorrow -- I am on the road for Fall Break currently.

Also, I discovered some massive errors with the way we were thinking about GObject and Gjs. Previously, we had been thinking that we were going to use Gjs to complete the C to Javascript bindings. However, after spending some more time researching exactly what GObject / Gjs is, I realized that we misunderstood the two libraries. GObject allows you to write C code in such a manner that Javascript / Python / other languages can call the functions. Gjs is a specific set of bindings for GNOME. So we should be researching the GObject documentation, but Gjs is an example of what the final output from a user perspective might look like. Realizing this clarified many points of the project for me, and I spent the week researching GObject documentation and reviewing the sample code and tutorials they have provided on their website.

I now have a very clear perspective on what needs to be done. This week, I will begin to write example bindings. The goal is that by next Friday I will have a) a working example plug-in and b) working example bindings. From there, the difficult part will be to combine these two sets of skills to make the GIMP Javascript bindings.

#week 4 #progress

Week 3: Struggles

This week was less productive than I hoped. I had hoped to quickly make the plug-in I coded last week register and then go to Gjs documentation and start to understand C to Javascript bindings. I also wanted to create a small set of bindings from C to Javascript, but that definitely did not happen. However, the first part of this was more tricky than I had anticipated. It took me much longer to make the plug-in registered. I ran into a few issues:

The instructions kept saying “just run this script” but I didn’t know where to put the file or where the script was located. While grep helped me with some of this, it still took me a while to get going.

A lot of the documentation is written as though you have been working with GIMP for years (or feels like that to me).

The documentation kept linking to other documentation / tutorials, some of which were inconsistent.

I finally got it working (EDIT: just realized that the plug-in is installing, but not registering -> follow the struggles here), but that meant that I had little time to start learning about Gjs. I have located some useful tutorials and will continue to update our documentation. Another interesting (nerve-wracking!) task I completed this week was emailing the listserv to inform them of our plans. I haven’t received any replies yet, and I actually think that’s good news.

Our check-in was on Sunday. It was just a basic check-in where we told Sam what we were working on and then also confirmed that it was okay to begin to alter some of the gimp code base we had installed to our computers.

The next week, I will continue to lean about Gjs and complete the goals that I had for this week. Apparently, the most trouble that I’ve been facing is with understanding the architecture of GIMP, but hopefully I will not run into any major issues. Also, fall break is coming up! I have a lot of time, so I really hope to get some work done then.

#week 3 #struggles #first plug-in

Week 2: Understanding Plug-In Architecture

First real week of work has been completed! This week, I spent some time in the code base and on Google trying to find good documentation and understanding script_fu code. I finally understand the basic architecture of a GIMP plug-in! There are two basic parts: query() and run(). I fully understand query. Run is more complicated since that’s where the actual actions of the plug-in happen, but I have found some good resources to guide me through understanding this section as well. As usual, I have been updating resources and my knowledge in our wiki.

I also wrote a small “test” plug in (found here). It’s not quite complete (the run code is still a stub) and I’m afraid to put it into the code base to test it. We haven’t had our check-in with Sam for the week (it’s on Sunday at 2pm via Google Hangouts), but I will ask him if it’s a) okay to mess around with the gimp source code and b) how to compile / re-run if it is. I’ll also post another blog post when this happens.

I also added myself to the GIMP developer listserv. Turns out some of the reasons that we’ve been having problems finding documentation is because the documentation is very fragmented - there’s a huge project to migrate it all to one location, but they have been running to copyright issues on some of it. There’s quite an interesting discussion on the listserv of how to combat this problem, and it nicely ties in some concepts from class. Another thing that I want to discuss with Sam this week is an email draft that I’m working on to send out to the developer listserv (still so nervous about reaching out to the community!).

The progress is not quite as easy as I had hoped (I also need to brush up on C), but I’m definitely making progress. Also, I’m understanding more vim features and bash features which are really helping! I think progress will start to speed up, especially when we learn how to add code to Gimp.

Next week, I plan to keep working on the small plug-in that I wrote, hopefully getting it to the place where I hope to later get my Javascript plug-in. I will also start looking more closely at the Gjs bindings and learning the syntax and methodology for those.

#week 2 #first code

Week 1

Gimp is up and running! Getting the development environment took a surprising amount of time (as a computer scientist, I really shouldn’t be surprised by this). It was really thanks to Sam (our mentor) that we are set up at all – he showed Scott and I some really awesome productivity tools and created the development environment.

We also had our first check in this week on Wednesday. During the check-in, we established the following short-term and long term goals:

Long-term: create a simple plug-in that interprets a Javascript script, registers it as a plug-in and writes “Hello World”

Long-term: improve documentation and ensure that code is well-commented

Short-term: use the community resources (IRC, listserv and) to understand how to write and run a plug-in

We also investigated the source code together, finding some functions that seemed to be a good starting point. Specifically, we are looking at the script-fu library because it appears to be the most robust.

I’m really excited about working on a project with such a large scope and an active development community! Overall, we accomplished as much as we wanted to this week in terms of getting started. This upcoming week, we plan to spend more time in the source code, adding to our wiki that contains our documentation and plans. We'll be focusing on researching the existing code base so we can “Plan the code” and later “Code the plan.” The biggest stumbling block we might face is that the code is very poorly commented, which might make understanding it difficult.

I am very happy about my choice of project and I am so excited to see what this semester will bring!! (Cue Minions)

#week 1 #development environment #goals

Coding @ Comcast

First day = success! Set up my development environment, began reading documentation and going through code. Definitely feel in over my head, but that’s how it always starts :)

Trending Blogs

Recently Viewed Blogs

Open Source Adventures