Tuesday, May 15, 2018

Storyboards/Interface Builder Vs. Programmatical Development/Direct in .swift

This week I studied some of the merits of creating the iOS in storyboard, using XCode's interface builder, versus a programatic development directly through the swift file (also in XCode).  The former strategy is best for the single developer or small team because storyboarding and its NIB files don't work with GIT distributed content management.  Secondly, the former is simply the greatest direct visual illustration or representation of what is being produced, rather than coding through what one imagines will be the result, which is fine, too; certainly that is what one does with HTML5/CSS3 front end.  In this way, it's simply the sheer brilliance of Apple to make it seem too easy.  But the latter makes more sense when the size, scale and/or dynamism of the app are either too unwieldy or complicated for a storyboard layout.  With respect to the size, are the so many scenes that you'd have to time-consumingly populate each one with material that could better be sent over programmatically, which would turn out to be a more efficient method?  With respect to dynamism, in other words, does the user swipe through a static stack of pages or do they affect the direction/the flow and change the page that is called based on their input?  Programmatic development is superior when one wants to dynamically call upon a diverse variety of data that may be inserted into its place on the page, based on the user's input.  A good example of this, which one of the tutorials I watched is doing, is the "Choose Your Own Adventure" app.  For my app, however, the on-boarding of the client is linear, so I'm using storyboards.  Frankly, it's also easier given the six-week timeframe of the course -- this is yet another merit of the storyboard, at least for someone of my entry-level skill level.  It's been much faster than I anticipated.

I particularly liked this discussion of the subject by Antonio Bello: https://www.toptal.com/ios/ios-user-interfaces-storyboards-vs-nibs-vs-custom-code

Monday, May 7, 2018

native, Swift iOS app via XCode!

I have such a sense of urgency with respect to building my app that it's almost hindering my progress!  But, joking aside, I've been given the good advice to avoid this pitfall by plugging along with more manageable, smaller parts, which is where I've kept my focus this week.  This week's progress has included implementing some of the app's architecture, connecting or stacking app scenes with navigation controllers, adding textual content as well as design and graphical assets.  The latter assets caused some delay, whilst I waited for them to be sent over.  I also switched gears and spent much work time completing the ILP, which is almost finished.  It was a mistake to hand code it because, even though I used the bootstrap framework, it still took longer than I had to give to it.  Otherwise, I won't spend too much time on this journal this week because I wrote about the effective meeting last week and am just really anxious to spend all my time building, programming.

Monday, April 23, 2018

Capstone Class Orientation

This week marks the beginning of our capstone class.  I delivered my proposal to build an iOS app for lastwish.com, which I'm pretty excited about since I'd like to become an iOS app developer after graduation.  Orientation on Saturday was surprisingly fun, as well as interesting, because I think my colleagues have some very good, impressive ideas for their projects.  Wishing everybody lots of success and good luck as we set out.

For our journal entries this week, we were asked to read about the characteristics or indicators of effective, high-quality meetings that get results.  Although I'll work on my project alone, so won't have the opportunity to exercise my collaboration and people skills this quarter, these are still valuable lessons to review that one might draw upon throughout one's life and career, and some of which I have heard mentioned before.  It's not an uncommon complaint to hear that one has too many pointless meetings and, perhaps, not enough time or the means to achieve real results.  And I'll certainly have meetings with my advisors and client, with whom I should try to exercise these best practices.

According to Heathfield at thebalancecareers.com, firstly, prior to any meeting's taking place, one should determine what are its goals and ensure it's even necessary in the first place.  If so, gather the appropriate people together and provide them with necessary, relevant materials in advance.  Secondly, during the meeting, a facilitator should take on certain responsibilities, such as sharing an agenda, reviewing goals, and eliciting input from all participants, as quiet or extroverted as they may be.  Controversially, perhaps, the writer argues that having set an expectation for all participants that they should likely be called upon to speak to any of the materials that had been distributed prior, ensures that the participants come thoughtfully prepared, since they won't want to appear otherwise.  Additionally, this stage also includes setting clear follow-up duties at the end of the meeting.  Lastly, after the meeting, minutes should be available, and participants should be held accountable for task completion.  Debriefing is also useful for discussing what was and what was not effective or of value in the meeting itself.

Tuesday, August 1, 2017

Gantt and Algorithms

Even if I won't be using Gantt Charts with agile development, since they fit instead under the waterfall methodology, and, furthermore, although I am not pursuing a job as a project manager, it's still interesting to have sat down this week and set up the tasks, resources and dependencies that make up such a project timeline.  They're a smart tool for planning that may be applied to many different types of projects.

In our other class, the algorithms class, we completed and submitted our last homework assignment today.  I'm feeling pretty tired, but more confident in my ability to design algorithms and apply or translate algorithmic pseudocode to C++ programming or any language I've learned, for that matter, which is pretty great.  In specific, writing the backtracking code to the (dynamic programming) coin row problem was particularly satisfying because, although it involved a few "Hail Marys" in my running it, it was challenging for me and something I built without pseudocode.  It might be easy to whomever might be reading this blog, but for me, it was not that easy.  Resolving it was definitely an "it's working" moment.  (All this is not to say that translating pseudocode is not without challenges or value.)  I came close to giving up, twice, but thought, hey, I might be on to something.  Keep coding.  Just see where this leads.  In the past, I'm unsure I would have felt such confidence to persevere through what I felt was a difficult (challenging enough to me) programming problem like this.

Tuesday, July 18, 2017

Peer Reviews

This week we read a variety of articles about the peer review, which is essential for code quality and thus reduces development time, while we continue to work on our team project.  My story involved creating a new schema with a variety of tables, which I then used to reverse engineer, or generate, a UML diagram, (far nicer, to me, than hand drafting one), as well as create the entity classes in netbeans.  Our team is meeting in weekly sprints to review code and plan next steps.



Tuesday, July 4, 2017

Scrumming away and happy fourth of July, everybody!

The team and I had a good initial meeting with Professor Wisneski and are amping up our project to transform our J2EE version of Hangman into a Wheel of Fortune game. We're continuing with sprint meetings, checking out code and making branches on github, recording activity in the collaboration and version control tool, PivitolTracker, doing test driven development and code review for pull requests.  Stuff like that.  It's great practice for the workplace, which is exciting.

Tuesday, June 13, 2017

Midterms/Finals Week

Finals at the mid-term--sounds odd, yet that is sort of what is going on this week!  In any case, it's exams time, and I'm cramming to ensure that I understand the topics we've been learning, including agile methodologies, junit testing, scalability, user diagrams and J2EE with its Java Sever Pages and servlets, as well as entity managers and persistence files connecting it all to MySQL's database servers.  It's been a challenge, and I'm grateful that NetBeans auto-generates so well!  Ha-ha.  I'm planning on poring through Murach's textbook again and hopefully achieving the deeper understanding that I've been wanting to attain for the client/server relationship.