00:--
Initial sketch of the thought on my notebook ( pretty chaotic at first )
00:--
After few iterations – a bit more refined version of the concept
// Implementing the Logic
01:35:
Setup the new development environment (...obligatory “Hello world!”)
05:16:
Planned out first draft product models and model relationships
10:38: Setup Motion model
11:32: Setup Motion controller and routes
12:29: Created new/create/edit/update/destroy view templates for motions
18:22: Created Assertion Relations model to establish parent - counter relationship
24:53: Created assertion profile page
29:51: Imbedded counter assertions under assertion page
36:41: Created embedded support inputs list on assertion page
38:40: Implemented support rating system to assertion model to aggregate and calculate support inputs
39:27: Implemented support rating system to motion model
40:10: Implemented support / counter count and total rating system to motion model and views
// Defining & Applying the Aesthetic
48:37: Brainstormed the aesthetic and UX direction of the product
49:36: Curated typography and color palette
50:20:
Sketched the layout for motion page
52:12:
Sketched the layout for assertion page
60:36: Created the layout for motions page and implemented color sliding scale to correspond with support level
64:10: Designed and coded layout for supporting & counter assertions
66:07: Updated support / counter assertion list layout to mute disregarded assertions
69:33: Created the layout for assertion main content
70:05: Created layout for counter assertion to assertion section
71:54: Created the layout for assertion parent heading
72:58: Created the layout for evidence list
77:39: Created the layout for support input
79:18: Created the layout for support input list
81:25: Created layout for support input cards
83:19: Designed user page
84:27: Created the layout for user ID card
88:26: Created the layout for motions index page
89:04: Divided motions page into two separate parts
[ ... tied up loose ends ... ]
99:59: Deployed the app in production
Check out the pre-alpha demo of TRUEST.
Link to the FULL devlog of the week.
If you have any feedback or inquiries please reach out to [email protected]!
I’ve always been deeply frustrated about the current online environment for discussing important matters and finding out truth about what’s going on around the world. Online comment section is synonymous with chaos and vitriol and our generation is quickly losing confidence in large media outlets. I find that fact really unfortunate because I believe the internet is one of the most powerful promoter of democracy and freedom of information.
That is why I decided to build TRUEST. Where people can find what is the objective truth. ...Or something closest to that – collective consensus based on empirical evidence. Following is the devlog of the past week where I put 100 hours into creating the first version of this platform.
Soon I’ll be posting pictures that goes along with the log as well. Please feel free to reach out if you have any questions.
TRUEST
Total Time: 100:00
Nov 30, 2015, 3:16 PM
00:00: Project started
00:20: Updated Ruby & Ruby on Rails Versions
00:56: Setup a new development environment with a set of new tools [Atom text editor, iTerm2 command line tool]
01:25: Setup the project
01:35: Hello world!
02:03: Setup Heroku and deployed the initial state app
02:43: Sketched out general layout for the initial pages
03:25: Learned the basics of Rspec
04:14: Reviewed the fundamentals of Behavior Driven Development & set up BDD stack
04:33: Wrote the first spec
05:16: Planned out first draft product models and model relationships
05:47: Researched the ways to effectively implement voting system in Rails
06:21: Expanded first draft product model to include two-part rating system
06:48: Converted product model sketch into a database models
07:21: Created the user model and authentication system
07:56: Created signup/login/logout views
08:26: Wrote user model spec tests for validation
09:09: Learned further about RSpec & Shoulda-matcher gem and expanded user model spect tests
09:45: Created user edit/update page
10:38: Setup Motion model
11:32: Setup Motion controller and routes
12:29: Created new/create/edit/update/destroy view templates for motions
12:58: Established relationship between user - motions controllers & models
13:19: Day 2
13:51: Created database seed for development and debugging
14:20: Updated the motion views to reflect relationships with the user model
14:44: Deployed the app in production
15:32: Sketched out Support Assertion & Counter Assertion models
16:28: Researched different methods and frameworks for implementing tree structure in Rails
17:20: Set up Assertion model and the related database
18:22: Created Assertion Relations model to establish parent - counter relationship
19:04: Added model validations to Assertion
20:11: Revised self referential model to have has-one & has-many relationship
20:42: Created Assertion controller
22:13: Revised and experimented with has-one & has-many relationship
22:49: Created new assertion page
23:04: Created edit assertion page
23:44: Scripted instance method to motion model to divided supporting and counter assertions
24:28: Created embed supporting/counter assertion views in motion view
24:53: Created assertion profile page
25:16: Cleanup views and links across the app
25:39: Sketched out and set up Evidence model
26:24: Learned about accepts_nested_attributes_for feature and how to implement nested forms for Assertion & Evidence
27:44: Implemented nested attributes feature to embed Evidence model within Assertion
28:19: Updated assertion page to list embedded list of evidences
28:54: Updated nested model to automatically serve up 5 fields for evidences & set up validations
29:07: Day 3
29:51: Imbedded counter assertions under assertion page
30:25: Fixed a bug where form resubmission lost http parameters
30:53: Created database seed for assertions & evidences
31:23: Expanded the database seed with the use of Faker gem
32:25: Sketched out SupportInput model
33:09: Set up SupportInput model
33:34: Researched different voting methods and mechanics
34:06: Decided simple yes/no choice would be the most intuitive solution yet provide enough information when aggregated
34:43: Created support input model validations
35:26: Created support inputs controller
36:13: Created embedded support input form on assertion page
36:41: Created embedded support inputs list on assertion page
37:35: Addressed logistical issues and added additional validations for support inputs
38:01: Expanded database seed to generate support inputs
38:40: Implemented support rating system to assertion model to aggregate and calculate support inputs
38:54: Implemented support rating to assertion view
39:27: Implemented support rating system to motion model
40:10: Implemented support / counter count and total rating system to motion model and views
40:34: Implemented participation minimum threshold for motion model
40:52: Implemented minimum threshold for motion views
41:44: Refactored views to be more modular
42:06: Day 4
42:43: Created assertion counter system and updated motion support rating system to reject countered assertions
43:39: Created column in database to store support count and implemented count increment / decrement system in order to optimize performance
44:22: Added username to user model
45:31: Implemented username validation and automatic default username generation feature
46:25: Learned about implementations regex and how to reserve certain words for internal use
47:19: Completed first draft minimum viable product
48:37: Brainstormed the aesthetic and UX direction of the product
49:36: Curated typography and color palette
50:20: Sketched the layout for motion page
51:32: Reviewed and researched web design principles
52:12: Sketched the layout for assertion page
52:30: Setup fonts in asset pipeline
53:11: Learned about HAML markup language to clean up views
53:25: Also learned about Slim template language
53:49: Converted first view over to Slim language syntax
54:59: Designed and coded the layout for site header
56:23: Designed and coded the product logo and refactored the stylesheet to prepare for mobile implementation
56:56: Created the preliminary layout for the welcome page
58:18: Day 5
60:36: Created the layout for motions page and implemented color sliding scale to correspond with support level
61:47: Created the layout for authorship and implemented custom date format method
64:10: Designed and coded layout for supporting & counter assertions
65:29: Implemented support based sorting system
66:07: Updated support / counter assertion list layout to mute disregarded assertions
66:57: Created button layouts and added new assertion button to motion page
67:31: Added edit / delete motion buttons
68:06: Reviewed and completed layouts for motion page
68:57: Created the layout for assertion header
69:33: Created the layout for assertion main content
70:05: Created layout for counter assertion to assertion section
71:54: Created the layout for assertion parent heading
72:24: Added fade in and transition animations
72:58: Created the layout for evidence list
72:58: Day 6
73:29: Configured paragraph typography
73:58: Added new assertion button to assertion page
74:37: Created half section division for assertion page
75:32: Learned how to create custom layouts for form items
76:23: Created custom radio buttons for support inputs
77:39: Created the layout for support input text area
77:54: Added support input submit button
78:10: Created the layout for error messages
79:18: Created the layout for support input list
81:25: Created layout for support input cards
82:30: Added additional sorting system and validations for support inputs
83:19: Designed user page
84:27: Created the layout for user ID card
85:07: Completed the first draft layout for user page
86:06: Updated user page & assertion page & motion page to be responsive for mobile devices
87:12: Created the functions to sort motions by date and total rating
88:26: Created the layout for motions index page
89:04: Divided motions page into two separate parts
89:55: Day 7
90:06: Added add new motion button to motion index page
90:34: Removed all content creation links for non-logged in users
90:58: Implemented color coded layout for all motion rating markers
91:31: Implemented highlights to navigation bars when motion or profile picture is toggled
93:09: Created the layout for new motion page
93:40: Fixed layout issues from browser default stylings
95:30: Created the layout for new assertion page
96:14: Embedded evidences form within new assertion page
96:57: Created the layout for edit motion page
98:01: Created the layout for signup page
98:30: Created the layout for edit user page
98:59: Created the layout for login page
99:19: Created the layout for edit assertion page
99:50: Updated error messages to be human friendly
99:59: Deployed the app in production
100:00: Created TRUEST MVP! ( minimum viable product )
Past few weeks I’ve been developing the iPhone version of my social networking platform. (cliqe.co)
On one of my last posts, I wrote about how I learned & created an Application Programming Interface (API) atop of my backend Rails application. Since then I’ve learned further about how HTTP networking requests are handled in iOS, how to upload files to a backend server from iOS, ways handle and display effectively throughout the application, etc.
Here are some screenshots of the app version 1:
- Now (Updates) Page
- Groups Page
- Invites Page
- User Account Page
- New Post Prompt
- Group Page
There are still a few features I want to implement before I considered this app complete, but the foundation for the app has been laid out. If you are interested in development of this app, stay tuned for more updates to come!
Complete Dev Log:
Cliqe on iOS
Total Time: 112:14
Sep 1, 2015 –
Oct 1, 2015
00:00: Project started
00:13: Begun practice project for using Rails API w/ iOS app
00:35: Setup the practice Rails API project
01:29: Setup a basic HTTP request from practice iOS app
02:20: Sent first POST request to rails served from iOS app
02:47: Successfully executed signup/signin authentication between rails API and iOS app
03:46: Learned about Alamofire framework and its basic uses in HTTP networking
04:10: Reviewed REST architecture in context of Rails
04:24: Learned how to setup routes for Rails API and render JSON data via get request
04:50: Learned how to setup rails API to receive POST requests
04:55: Learned how to return messages & data for POST requests
05:09: Learned how to setup Rails API for PUT & DELETE requests
05:31: Learned how to setup Rails API for nested models
05:41: Learned how to use as_json function to customize JSON output
06:05: Learned how to implement basic authentication with rails API
06:31: Setup namespaces for Cliqe API
06:52: Setup users API for show/GET request
07:02: Included group and invitation data to users JSON data
07:43: Setup users API for create/POST request
08:21: Setup users API for update/PUT & destroy/DELETE request
09:04: Implemented basic API authentication
09:36: Debugged an error with POST requests
09:54: Learned about parameter wrapping in rails and fixed scope issue with JSON requests
10:24: Finished implementing Users API
10:50: Learned about rails API versioning
11:21: Set up versioning for Cliqe API
12:21: Set up groups API
12:41: Tested groups API
13:11: Learned how to include virtual attributes with JSON outputs
13:40: Set up invites API
14:08: Tested invites API
14:49: Debugged and fixed validation issues with invites model
15:34: Set up posts API
15:52: Tested posts API
15:58: Begun development of the iOS client
16:16: Implemented login function for rails user API
16:38: Researched best practices for error handling with rails API
17:09: Inserted Alamofire into the Cliqe client app
17:38: First API request successfully sent from Cliqe client app
17:49: First successful authentication via API
17:59: Learned about SwiftyJSON framework
18:04: Inserted SwiftyJSON framework into the app
18:30: Implemented SwiftyJSON
19:31: Created custom function to make HTTP requests more reusable and specific for the uses within the app
19:59: First POST request sent from the client
20:22: Updated rails API to output printable error messages
20:32: First PUT request sent from the client
20:46: First DELETE request sent from the client
21:15: Learned about best practices for storing confidential information in iOS
21:44: Learned about iOS Keychain and Security framework
23:09: Implemented iOS keychain to securely save user passwords
23:30: Implemented HTTP authentication system in conjunction with iOS keychain
24:00: Completed implementing client side communication with the rails API
24:20: Configured the preliminary layout for the main page
24:46: Configured the preliminary layout for the login page
25:21: Configured the preliminary layout for the signup page
25:48: Setup basic navigation control
26:29: Implemented third party keyboard control code library to fix the problem where the keyboard popup covered text fields
27:25: Implemented login functionality
27:42: Implemented signup functionality
27:55: Added alert messages for login & signup page
28:28: Established connection between user page to login & signup page
28:51: Created central app helper class to reduce code duplication and aid development speed
29:27: Created custom animation for login / signup to user page
30:06: Updated login & signup function to store user information to Keychain
30:41: Created preliminary layout for user page
31:15: Created User and Group model to handle fetched JSON data
31:52: Implemented user view to dynamically respond to JSON data fetched from the API
32:09: Week 2
32:36: Reading about design principles for mobile platforms
33:15: Started developing the main design for the first draft of cliqe iOS
33:39: Created updated layout for user page
34:12: Updates user & group model to have optional relationship with users or groups
34:46: Learned how to pass data between view controllers connected by UITabBarController
35:18: Created the layout for groups page & linked it with the database
35:46: Learned how to embed UICollectionView within UITableViewCell
37:41: Created dynamic collection view to display user icons in each group preview
37:58: Begun designing groups page
38:38: Created preliminary design for groups page
39:42: Configured the group view controller
40:12: Reconfigured navigation control configuration
40:53: Updated rails API to expand post model
41:22: Created post model in client application
42:08: Created dynamic group page corresponding to data fetches from the rails API
42:38: Added group users collection view to the group page
43:16: Updated group list and group view layout
43:49: Added toolbar to the group page
44:40: Updated navigation bar and tool bar layout
45:19: Updated layout for Now page & Inbox page
45:31: Setup rails API for iOS Now page
46:14: Fixed posts layout constraint issues
46:54: Setup layout for now page
47:29: Created dynamic now page corresponding to data fetched from the rails API
48:06: Expanded invites model in Rails API for client app uses
48:21: Set up invites model in the client app
48:55: Created dynamic inbox page corresponding to data fetched from the rails API
49:41: Updated group navigation bar
50:17: Optimized the app for faster loading time
51:32: Added user add section & functionality
52:01: Added toggle animation for user add section
52:32: Updated navigation bar font style
53:13: Added invitation deletion functionality
54:00: Added invitation accept functionality
54:41: Implemented dynamic view height for the group users view
55:10: Week 3
55:39: Learned about web sockets and third party push notification services
56:38: Learned about most cost effective way to incorporate real time messaging system in a secure way
57:09: Begun implementing create new post functionality
57:32: Fixed user groups collection view layout bug
58:18: Revised group page to only include create post - no chat - for the first version of the app
58:41: Updated invite new user section to dismiss when keyboard is dismissed
59:30: Created create new post window
60:53: Created custom keyboard toolbar for new post window
61:22: Updated keyboard toolbar layout
62:45: Wired new post window with user data
63:52: Implemented new post POST HTTP request for the client to the API
64:41: Updated data models to classes from structs to allow data binding
65:22: Optimized events after new post creation in order to improve user experience
66:16: Week 4
66:48: Fixed loading bug with group users collection view
67:44: Updated Now page post descriptions
68:21: Created link from Now page post to related group page
69:08: Learned further about reference cycles in closures
70:19: Created automatic redirect to the group when invitation is accepted
71:40: Create new group creation page
72:14: Added new group controller & implemented group length validation
72:47: Implemented create new group functionality & automatic redirect to newly created group page
73:26: Created embedded invite button alongside group users collection view
73:53: Updated invite button layout
75:04: Gathered icon assets and created xcassets items for each icons
75:40: Applied icons for the app UI
76:26: Created UIButton class to create tinted icon effect
77:14: Added group settings page
77:43: Created group settings page layout
78:33: Set up group settings page controller
79:22: Implemented leave group functionality
79:52: Learned about NSNotification center and how to implement it
80:42: Implemented NSNotificationCenter to handle data change app-wide
81:33: Created app-wide function to organize all NSNotification broadcasts and subscriptions
82:19: Implemented edit group functionality
82:30: Created NSNotification broadcasts for group create, delete, and edit
82:49: Added user settings page
83:28: Set up layouts for user account page
84:11: Set up layouts for edit user account page
85:10: Created app function to retrieve and store current user data on launch
85:58: Wired user account page with database
86:23: Implement User class function to output profile picture image
86:57: Wired edit user account page with database
87:45: Created edit user account function
88:33: Created security measure to logout users when user credentials were changed remotely
89:20: Improved security measures to check if user credentials were changed every time user opens the app
90:00: Added additional layer of security by checking user credentials when API call fails
90:14: Added friendly redirect message
90:47: Created background view and message for empty page
92:00: Created offline indicator message
92:37: Updated background view layout for empty pages
93:19: Added refresh button with background view for empty pages
93:53: Added add new group button for background view for empty groups page
94:30: Implemented logout function
95:23: Updated new post page
95:52: Implemented refresh control to group page
96:15: Implemented refresh control to inbox page
96:24: Implemented refresh control to groups page
96:32: Implemented refresh control to now page
96:48: Updated alert view layouts
97:36: Updated login / signup page layouts
98:19: Learned about file uploading in iOS
99:16: Created first draft file uploading function
100:00: 100 hour mark!
100:36: Learned more in depth about how HTTP Multipart request is handled
101:26: Reviewed UIImagePickerController class
101:53: Set up edit user profile picture page
102:24: Set up edit user profile picture controller
103:09: Set up profile image picker
104:16: Created File struct & FileType enum to handle data for file upload
105:50: Created second draft file uploading function
106:46: Learned further about HTTP Body types
108:26: After research, decided against multipart implementation & decided to implement separate requests for files and information
109:34: First file uploaded from iOS to Rails Backened
109:47: Updated profile picture uploading for better user experience
111:12: Implemented image processing to created rounded edges and circle images
112:14: Updated app and applied image styles for user profile pictures
Documented w/ Point A
Point A: Bring back your focus -Less planning & More doing
The first version of Point A is now downloadable worldwide on the App Store!
What is Point A?
Point A is an app that integrates conventional note taking & timer apps and adds to it by incorporating detailed analytics to help you document your progress on your projects, studies, or whatever you are working on.
The central idea of Point A is to keep you motivated and focused on your work – not by making more plans or setting unmanageable goals, but by documenting & analyzing what you’ve actually accomplished.
Join me on my journey today –
My app is available to everyone for free of charge & there are no ads.
For the first week of developing iPhone version of my social networking platform (cliqe.co), I decided to build an API for my rails application & learn how to set up the iPhone app to communicate with the Rails app.
This week I learned:
How to build Rails API (teamtreehouse.com)
How to use curl command line tool to send HTTP requests (teamtreehouse.com)
The best practices for setting up secure API (stack overflow)
Alamofire framework for handling HTTP requests (github)
SwiftyJSON framework for handling JSON data (github)
The best practices for storing sensitive data within iOS app & how to implement iOS keychain (stack overflow)
This week I built:
RESTful Rails API
iOS client application
Cliqe on iOS
Total Time: 32:13
Sep 8, 2015, 3:57 PM
00:00: Project started
00:13: Begun practice project for using Rails API w/ iOS app
00:35: Setup the practice Rails API project
01:29: Setup a basic HTTP request from practice iOS app
02:20: Sent first POST request to rails served from iOS app
02:47: Successfully executed signup/signin authentication between rails API and iOS app
03:46: Learned about Alamofire framework and its basic uses in HTTP networking
04:10: Reviewed REST architecture in context of Rails
04:24: Learned how to setup routes for Rails API and render JSON data via get request
04:50: Learned how to setup rails API to receive POST requests
04:55: Learned how to return messages & data for POST requests
05:09: Learned how to setup Rails API for PUT & DELETE requests
05:31: Learned how to setup Rails API for nested models
05:41: Learned how to use as_json function to customize JSON output
06:05: Learned how to implement basic authentication with rails API
06:31: Setup namespaces for Cliqe API
06:52: Setup users API for show/GET request
07:02: Included group and invitation data to users JSON data
07:43: Setup users API for create/POST request
08:21: Setup users API for update/PUT & destroy/DELETE request
09:04: Implemented basic API authentication
09:36: Debugged an error with POST requests
09:54: Learned about parameter wrapping in rails and fixed scope issue with JSON requests
10:24: Finished implementing Users API
10:50: Learned about rails API versioning
11:21: Set up versioning for Cliqe API
12:21: Set up groups API
12:41: Tested groups API
13:11: Learned how to include virtual attributes with JSON outputs
13:40: Set up invites API
14:08: Tested invites API
14:49: Debugged and fixed validation issues with invites model
15:34: Set up posts API
15:52: Tested posts API
15:58: Begun development of the iOS client
16:16: Implemented login function for rails user API
16:38: Researched best practices for error handling with rails API
17:09: Inserted Alamofire into the Cliqe client app
17:38: First API request successfully sent from Cliqe client app
17:49: First successful authentication via API
17:59: Learned about SwiftyJSON framework
18:04: Inserted SwiftyJSON framework into the app
18:30: Implemented SwiftyJSON
19:31: Created custom function to make HTTP requests more reusable and specific for the uses within the app
19:59: First POST request sent from the client
20:22: Updated rails API to output printable error messages
20:32: First PUT request sent from the client
20:46: First DELETE request sent from the client
21:15: Learned about best practices for storing confidential information in iOS
21:44: Learned about iOS Keychain and Security framework
23:09: Implemented iOS keychain to securely save user passwords
23:30: Implemented HTTP authentication system in conjunction with iOS keychain
24:00: Completed implementing client side communication with the rails API
24:20: Configured the preliminary layout for the main page
24:46: Configured the preliminary layout for the login page
25:21: Configured the preliminary layout for the signup page
25:48: Setup basic navigation control
26:29: Implemented third party keyboard control code library to fix the problem where the keyboard popup covered text fields
27:25: Implemented login functionality
27:42: Implemented signup functionality
27:55: Added alert messages for login & signup page
28:28: Established connection between user page to login & signup page
28:51: Created central app helper class to reduce code duplication and aid development speed
29:27: Created custom animation for login / signup to user page
30:06: Updated login & signup function to store user information to Keychain
30:41: Created preliminary layout for user page
31:15: Created User and Group model to handle fetched JSON data
31:52: Implemented user view to dynamically respond to JSON data fetched from the API
After my preliminary version of ruby on rails social network was deployed on the web, I quickly realized that, to create an application that people would want to use it is absolutely necessary to create a mobile application for it as well.
So I dedicated the first 3 weeks of August to learn Objective-C & Swift (Apple’s new programming language) and develop a fully functional mobile application.
This began as a way to develop the mobile app for my social networking site, but it happened to take a slightly different turn.
Here is a quick (-ish) summary of what happened:
The First Week
I spent all of my time taking a Objective-C Course from Teamtreehouse.com and built 6 demo application including one I’ve designed.
- In that week, I learned fundamentals of Objective-C & iOS (Cocoa Touch) framework, built basic snapchat-type app, third-party Instagram app, and designed & built sort-of-finished social rock paper scissors app.
... my first super basic iOS app.
The Second Week
I first took the Swift course from the teamtreehose.com. After completion I was quite dissatisfied the depth & coverage of the course, so I decided to get right to the official Swift Programming Language book by Apple.
- After completing the book, I was ready to start developing my first prototype app in Swift. But I wasn’t sure what I was going to build before fully jumping into building the app for my social networking site. I immediately started thinking about what I would want to use. So I decided to build an app to help me with the very process that I was partaking in – learning new things and documenting my progress.
Up to this point, I had been using several different tools to help me organize my learning & documentation process – such as todo-lists, timers, notepads for writing things down... etc. I tried using several apps and web extensions in attempt to streamline my process, and ended using bunch of separate tools –chrome timer extension, apple stock timer & note pad, extra notepad file in my coding projects, and others. It was only natural that I begin the development of Point A – the tool to document, track, and share my progress.
For the last two days of second week I built a working prototype of the the app. I built a basic app with timer-notepad integration. It was what I was doing with different tools, just put into one place.
The conceptual design & initial implementation of the app
The Third Week
After building the first functional prototype of Point A I didn’t want this project to cease as simply as a prototype. I decided to make Point A into a full fledged app made available to everyone via the App Store.
This last week I’ve implemented:
- Notes export feature
- Notes sort-by-timespan feature
- Project list page & ability to create multiple objects
- Project analysis & graphs
- App settings ( Auto-pause feature & Idle-timer disable feature )
- Swipe navigation & custom transitions
& created / gathered all the data for app store submission
Screenshots of Point A - the Finished Product
Point A is currently in a review process in the app store. If you are interested in the details of the process, below is the complete notes from the third week documented & exported via Point A app.
Also, if you have any questions about learning process of Objective-C, Swift, deploying to the app store, Point A app, or whatever – please feel free to contact me anytime. I can be reached at [email protected] or [email protected]
Point A: Week 2
Total Time: 96:37
Aug 24, 2015, 7:55 AM
00:00: Begun update of Point A
00:39: Designed analysis page
01:23: Created preliminary layout for project list view
01:41: Saved color pallets
02:29: Learned how to create custom segues
03:30: Implemented segues for main view to project list view
04:07: wired project database for project list view
04:44: Created pause indicator
05:05: Added back button for project list view
05:59: Created layout for project add function
06:54: Added add-project functionality
07:22: Implement auto save feature
08:09: Added text field delegate & keyboard release functionality
08:48: Implemented switch-project functionality
09:32: Created projects delete functionality
09:54: Coded security measures to insure safe project deletion
10:29: Added alert messages
10:49: Implemented notes delete functionality
11:05: Applied alert message styling
11:19: Applied minor styling updates
11:37: Coded sort-by-last-update functionality for project list
12:25: Day 2
13:07: Configured layout for notes list view
13:57: Set up segue from embedded notes table to notes list view
14:30: wired database to note list view
15:33: Transformed header view into a custom navigation bar
16:06: Created custom navigation bar for project list view as well
16:52: Learned how to create files from iOS app
17:25: Setup the interface for exporting notes
18:16: Learned about UIActivityView Controller
18:53: Implemented UIActivityView Controller for exporting notes
19:42: Implemented formatting system to present all notes for email exports
20:00: Applied reverse sorting order to export format for readability
20:44: Applied new layout for status bar and note view
21:27: Set up the layout for segmented control
22:25: Implemented timespan filter for notes list view
23:07: Implemented sort-by desc / asc functionality for notes list view
24:25: Implemented export text customization functionality
24:57: Day 3
25:30: Updated layout for notes list view
26:19: Learned how to make charts & graphs in iOS framework
27:00: Set up preliminary layout for progress view
27:45: Designed preliminary version of charts & objectives table
28:19: Set up segue for main view - progress view
28:43: Redesigned progress view as overview view
29:21: Created layout for info section of overview view
30:02: Wired data to overview view
30:37: Scripted function for calculating day count between two dates
31:01: Starting a practice project for creating & drawing graph charts in iOS
31:26: First lines of graph rendered using custom UIView
32:41: Learned how to draw custom graphs using custom UIViews
33:14: Learned how to use IBInspectible to customize Interface Builder editor
35:08: Created the layout for the new GraphView
36:00: Day 4
36:50: Added selection point indicator for overview graph
37:20: Incorporated tuples to bundle graph data & format together
37:57: Connected project data to overview graph
38:29: Learned about NSCalendar & how to calculate dates
39:08: Restructured overview view : grouped segmented control with overview graph
40:01: Created TimedData struct to organize data filtered by days, weeks, or months
40:27: Coded function to calculate total note count & total time based on given timespan
41:11: Implemented aforementioned data parsing for daily-breakdown
41:36: Implemented data parsing for weekly-breakdown
42:14: Implemented data parsing for monthly-breakdown
42:37: Wired data parsing functions to segmented control
43:33: Passed parsed data to the graph
43:56: First dynamic graph rendered with parsed data
44:46: Set up axillary outlets for graph view
45:30: Wired data to axillary outlets for graph view
46:24: Learned how to implement gesture recognizers
46:54: Implemented tap gesture recognizer & linked it to graph view and database
47:39: Implemented alternate graph showing total number of notes
48:43: Day 5
49:27: Set up settings view, controller, and segue between overview - settings
50:33: Created the preliminary layout for settings page
50:58: Curated collection quotes for settings page
51:19: Set up the view & layout for the quote section
51:49: Set up data model for collection quotes
52:20: Implemented function to randomly display a quote in settings page
52:58: Learned about NSUserDefaults & how to implement user settings function
53:33: Implemented user settings function
54:14: Configured style for settings table cells
54:45: Setup segues & view controllers for each setting menus
55:22: Learned how to use Visual Effects view for blur effect
55:49: Setup table view for FAQ page
56:21: Format the cells for FAQ page
56:58: Redesigned FAQ & About page for better navigation between pages
57:26: Completed the layout for the FAQ page
57:47: Wired navigation controls for FAQ page
58:17: Wired navigation controls for about page
58:33: Learned about different options for implementing support email feature
59:17: Implemented support email feature
59:37: Implemented auto pause setting feature to the app
60:15: Implemented never idle timer disable feature to the app
60:24: Updated graph view to use proper suffix to reflect plurality
61:06: Wrote the contents for the FAQ page
61:32: Updated the FAQ page with new content
62:27: Learned about in-app-purchases and official guidelines
63:18: Day 6 ( ~ 7 )
64:01: Created contribution / support page
65:23: Researched & enrolled in Apple Developer Program
65:42: Registered a new app ID
66:14: Tested the app physically on iPhone 6
66:52: Updated layouts based on observations from physical testing
67:21: Fixed a bug where project list is not updated when you first launch the app
68:11: Updated auto pause setting for app wide use using NSNotification Center
68:49: Implemented initial note creation function for newly created projects
69:40: Implemented preliminary layout for contribute page
70:00: Wired segue from settings page to contribute page
70:36: Implemented visual effects view (blur background) to contribute page
71:02: Completed the layout for contribute page
71:27: Setup view controller for contribute page
72:15: Updated graph view to have minimum ceiling value to more naturally progress
73:13: Learned how to implement 'share this app' link
73:26: Decided to hide contribute button until app is released
74:13: Reviewed Official App Store Review Guidlines
74:39: Reviewed how to make custom segues
75:26: Implemented custom segues for overview & project list views
76:20: Implemented custom segues for settings page and its sub views
76:44: Learned how to implement unwind segues
77:15: Implemented unwind segues for overview & project list view
77:44: Implemented unwind segues for settings page & sub views
78:28: Updated navigation control items to better reflect the new segues
79:13: Updated layout styles for the app to create unity in design
79:30: Smoothed out some buggy areas
79:59: Fixed more bugs & inconsistencies
80:43: Implemented swipe gesture recognition & swipe navigation for the main view
81:21: Implemented swipe gesture control for settings page
83:32: Found an extremely pesky bug with the custom transition.... for some reason the background view in deep layer was glitching & showing up at random times. "Fixed it" by changing its color
84:14: Took screenshots for app store submission
84:48: Created layered screenshot images for all iPhone devices
85:40: Read apple's guide on how to distribute/manage apps
86:36: Created code signature & linked my app to my dev account
87:18: Fixed a critical bug where settings table selection was duplicated on double click
87:59: Test the app & implemented minor bug / layout fixes
88:51: Wrote the app description for the app store and settings page's about page
89:19: Completed the layout for about page
90:06: Revised app description.
91:00: Changed project name from PointA to Point A
93:15: Finalized app and archived to get ready for app store submission
94:15: Created Twitter Account for Point A App & Filled out Information for iTunes Connect
* Note: much of the progress in building the initial foundation took place behind the scenes. These pictures are a few of visual snippets I’ve managed to document. If you are interested in the complete log please read: http://tinyurl.com/o78aq8b
From Zero
00:47
Begun the development of the Prototype Application
07:54
Created rudimentary user page
21:34
Begun modeling of groups (Trials and errors… Many hours spent learning)
42:36
Begun modeling Post class
47:20
Created back-end & front-end system for creating new posts in groups
50:01
Added the first file uploader to the group
54:59
Added profile picture avatar & implemented them to show in various views
58:19
Added an audio uploader to the group page
62:44
Implemented file filtering system to view all files in that type (All pictures & All audio)
63:11
Applied basic CSS to streamline filtered files
66:04
Added glyphicons to buttons
67:07
Applied basic CSS to the group side menu
68:03
Added additional CSS to the group side menu and main view
68:29
Implemented sectional scrolling (Screenshot taken retrospectively)
78:51
Created the layout for Group Index view
84:56
Created the layout for Inbox view
85:57
Added the functionality to delete invitations
88:02
Updated group show view button layout & Column width
91:55
Implemented updated version of file uploader (upload button changes color & can be clicked again to discard file)
100:40
Created Welcome & About page & Updated layouts
101:00
Deployed first fully functional web application on the world wide web!
Deployment
Thank you for reading this post!
If you are interested in checking out this site please visit jkim.herokuapp.com
And stay tuned here for more updates about this app! I will be documenting all future updates and overall progress on this blog.
For this week of 100 Hour Challenge I’ve decided to build a social networking site. As a part of last challenge, I’ve completed Ruby on Rails Tutorial by Michael Hartl ( & Unity 2D ) -- and as an extension of the last challenge I’ve built my own web application.
The Prototype Application ( temporary name ) is a group focused content sharing platform built to deliver, store & organize contents you share with people. It is now deployed on temporary URL -- jkim.herokuapp.com -- if you are interested please feel free to use it!
Following this point is a complete log of the progress I’ve made this week.
Day 1
00:01
Beginning by reviewing rails tutorial by Michael Hartl & and the demo application from the last challenge
00:47
Begun the development of the Prototype Application
01:20
First repository on GitHub
01:28
Setup Heroku for production
01:43
First push to Heroku
02:07
First homepage post on localserver
02:30
Additional Review of Rails API
03:20
Added bootstrap
04:00
Added basic style & configured routes
05:20
Added user model & validations
05:48
Added password encryption & related validations
06:50
Precompiled assets for production
07:54
Created rudimentary user page
08:32
Created initial state user signup page
09:41
Completed user signup page
10:01
Added flash notification
11:02
Deployed ground level project to production
12:06
Setup initial state user login page
Day 2
14:30
Completed login functionality & alternate homepage for logged in users
15:17
Wrote login integration test
15:39
Added Logout functionality
16:19
Just learned that you cannot use "test_" in the beginning of test helper methods because it is already being used by Rails
16:58
Fixed compiling error with heroku...
bootstrap was not loading in production environment --
updated rails_12factor gem
& ran
RAILS_ENV=production bundle exec rake assets:precompile
to fix the problem
17:44
Added initial state user account update/settings page
18:40
Added integration test user account update
19:45
Implemented security measures to prevent not logged in users from accessing accounts
20:37
Implemented security measures to prevent wrong users from accessing other accounts
21:00
Designing app structure & model relationships for the next step
21:34
Begun modeling of groups
21:50
Show - shows the group page
New - creates new group
Edit - customize group customization
22:19
Reviewing model relationships
23:21
modeled memberships to bridge two way relationship between users - groups
24:06
Examining model relationship behaviors in rails console (sandbox)
24:30
Shaping Membership & Group model based on findings from examination
26:16
Added page for showing all of user's groups
27:55
Added group creation functionality for users
Day 3
28:25
Begun modeling of group invitations
28:44
Added initial state group show (main) page
29:43
Added validations to prevent users from accessing other groups that they not belong to
32:50
Created back-end system for sending a user group invitation
33:30
Created back-end system for accepting group invitations
35:50
Solving some database mystery... Created sender & recipient but only sender is created correctly & recipient is only created once
37:42
Created initial state front-end system for sending a user group invitation
38:40
Completed system for sending a user group invitation
39:50
Created front-end system for viewing your invitations
41:33
Completed system for accepting invitations
41:58
Added validations to prevent security issues & bugs
Day 4
42:36
Begun modeling Post class
42:54
Learning about image uploading options in Rails
Week 4 in Pictures:
{ Building Combat Foundations }
// Creating Support Character
01:32
Added sprite & animations for supporting character
02:03
Added the supporting character into the game
02:45
Wrote script for Logic_Companion
the supporting character follows & protects the player
// Mouse Control for Supporting Character
03:28
Wrote rudimentary script for detecting if mouse cursor hovering over a character
07:04
Created custom cursor & script for cursor behavior
08:40
Implemented system for controlling player's allies with cursor
Selecting an ally and right clicking on enemy prompts the ally to attack the enemy (screen capture taken retrospectively)
10:20
Implemented system for controlling player's allies location with cursor
(screen capture taken retrospectively)
// Second Player Character & Skins System
12:53
Created second character and animations
14:00
Now the player can be played as male or female
// Equipments & Attack Animation
17:30
Scripted Item class & Implemented item equipment system
19:55
Added first draft of attack animation in the game
// Staff & Projectiles
22:40
Created fire staff & animations
23:12
Added fire staff into the game
23:50
Created fire ball sprite & animations
25:32
Created script to summon projectile upon action
25:52
Wrote the script to make the projectiles fly towards the direction they were placed
27:14
Completed the implementation of projectile system
01:32
Added sprite & animations for supporting character
02:03
Added the supporting character into the game
02:45
Wrote script for Logic_Companion
the supporting character follows & protects the player
03:08
Improved companion logic
Now the companion attacks the same target as the player
Week 4 Day 2
03:28
Wrote rudimentary script for detecting if mouse cursor hovering over a character
03:54
Improved mouse cursor script to respond to character's sprite & Not collider
(In this game, the sprite is often larger than the collider because of the top half)
05:36
Improved mouse cursor script to precisely respond based on pixel value of the sprite
(Cursor will only respond if the pixel is not transparent)
06:02
Improved mouse cursor script to linger in between certain distance from the character after selection
(for what I believe to be a more seamless experience)
06:17
Improved mouse cursor script to respond correctly when dealing with scaled objects
07:04
Created custom cursor & script for cursor behavior
07:27
Improved mouse cursor script send information about selected object & prevent multiple selection
07:50
Created two custom icons to be used in combat
08:40
Implemented system for controlling player's allies with cursor
Selecting an ally and right clicking on enemy prompts the ally to attack the enemy
10:20
Implemented system for controlling player's allies location with cursor
10:51
Improved ally control -
Allies wait for player when moved to a location
11:40
Improved ally system -
cursor selection intelligently distinguishes allies and enemies
Now right click responds appropriately
12:18
Improved ally system -
now allies can follow custom targets other than the player
allies can follow each other or form a line
Week 4 Day 3
12:53
Created second character and animations
13:22
Created system for changing player's skins
14:00
Now the player can be played as male or female
14:32
Watching this (https://www.youtube.com/watch?t=1316&v=rMCLWt1DuqI)
video in order to learn more about sprite skin customization
14:52
Learning about the Resources folder
15:42
Implemented character skin switching system
16:18
Improved particle system - Now characters gradually bleed based on how much health they have left
17:30
Scripted Item class &
Implemented item equipment system
Week 4 Day 4
18:12
Researching pixel animations for applying tools and attacking
18:57
Created the first draft of player attack animation
19:19
Configuring new sprite layouts for player movement + actions
19:55
Added first draft of attack animation in the game
20:53
linked character attack script & animation
21:37
Improved character & equipment animation
Week 4 Day 5
22:40
Created fire staff & animations
23:12
Added fire staff into the game
23:50
Created fire ball sprite & animations
24:55
Created script to sync Projectile prefab & Character & Item attributes
25:32
Created script to summon projectile upon action
25:52
Wrote the script to make the projectiles fly towards the direction they were placed
26:30
projectiles now rotate to the direction they are flying
27:14
Completed the implementation of projectile system
Week 4 Day 6
27:45
Improved procedural placement script to include random chance decimal down to 0.01%
27:50
Beginning the implementation of mob spawning system
28:20
Created Mob Spawner class & editor script to configure spawn settings
29:16
Learned about Physics.OverlapArea and its variant functions
( to prevent mobs from occupied space )
29:40
Centralized terrain generation & day-night cycle components into the main GameManager
30:33
Finished implementing Character(Mob) Spawn system
The Characters will spawn based on their configured spawn time & with the specified frequency
31:21
Modifying the logic hierarchies to scan newly
spawned mobs
31:47
Updated character class to centralized all actions involving the object ( all references to object are updated to character class instead gameObject)
07:05
Successfully generated top-down tiled terrain using prefabs
08:30
Implemented Procedural Terrain Generation into the Prototype Game
// Making Intelligent Tiling System
13:25
Created byte based system for detecting adjacent tiles
14:33
Successfully implemented
auto tiling system
w/ procedural generation
19:00
Debugging a strange bug...
19:11
Squashed the bug &
Completed new tiling system
20:34
Added Deep Sea layer
// OPTIMIZATION
26:53
Created first randomly generated tiles using Texture + Plane instead of multiples of game objects
...
(MANY hours of performance optimization...)
(MANY hours of hacking codes...)
...
(test tiles with bitmaps printed)
40:49
Learned about Enums, Unity's Texture API, and
Successfully implemented new rendering technique & auto tiling system
Combined
Bitmap tiling system &
Runtime generated texture combinations
to create efficient automatic single-sprite tiling system
07:05
Successfully generated top-down tiled terrain using prefabs
07:20
Applying this new function to the Prototype Game
08:30
Implemented Procedural Terrain Generation into the Prototype Game
08:44
Created rudimentary script for Camera movement
Week 2 Day 3
- Making intelligent tiling system
09:06
Learning about 2D arrays
09:59
Created sub class 2D arrays containing index & position of all tiles
10:37
Created first 8-directional
water tile
10:43
Learning how to match tileset based on adjacent tiles
http://www.oldschoolpixels.com/?p=252
11:56
Created 56 variant of tiles for water (connecting positions)
13:25
Created byte based system for detecting adjacent tiles
14:33
Successfully implemented
auto tiling system
w/ procedural generation
Week 2 Day 4
- Improving intelligent tiling system
14:34
Decided to invert the tiling system (instead connecting from inside connect edges)
14:45
Created connected edges for grass tiles
16:34
Debugging and learning in depth about arrays & lists
16:58
Refactoring some code for performance optimization
17:17
Adding debugging UI tools
19:00
Debugging strange bug...
19:11
Squashed the bug &
Completed new tiling system
20:00
Assigned colliders to generated tiles
20:15
Improved diagonal character movements using vector2.normalized
20:34
Added Deep Sea layer
Week 2 Day 5
- Making terrain tiles into meshes for performance optimization
20:48
Starting with
Unity 3d: TileMaps Tutorial
https://www.youtube.com/watch?v=bpB4BApnKhM
21:09
Learned exactly why I shouldn't use GameObjects for each tiles
21:59
Learned about fundamentals of Meshes (vertices, triangles, normals, uvs)
23:01
Created custom editor with a button & a slider bar
26:24
Learned how to apply a texture's pixels onto another texture in context of tile mapping
26:53
Created first randomly generated tiles using Texture + Plane instead of multiples of game objects
27:02
Learned how to store texture tile data into an array
27:45
Planned out system structures for implementing new tile system to the Prototype game
Week 2 Day 6
28:07
Starting the implementation of the new tile rendering technique to the Prototype game
29:50
Implemented initial state of the new tile rendering script
31:09
Spent over an hour catching the bug with instantiating plane on the map
-> Turned out that I was trying to manipulate variables set in Start() instead of Awake()
32:07
Finding that somehow instantiating a batch of gameObjects is much faster than drawing in on the mesh
Conflicted & need to figure out if it is because of the code structure or the engine
32:14
The culprit was the fact that texture.Apply() function was being called for every tile, thus slowing the process down
32:44
Successfully rendered the map using the new technique
- for some reason (maybe just the engine) it is still slightly faster to instantiate each tile as Game Object
- I am sure though, it will be much better for the performance after the initialization of the terrain
32:46
Beginning the implementation of new auto tiling concept
34:45
Learned how to use transparent materials & implemented multi-layer tiling
35:21
Having each layer for each height seems ideal, but it is making terrain generation much slower
Opting to add second layer only for the edges of the tiles
35:41
Brought back the multi-layer with help with optimization
35:49
Starting the main implementation of the auto tiling connecting concept
36:56
Created Auto tile textures based on a template inspired by RPG MAKER
40:49
Learned about Enums, Unity's Texture API, and Successfully finished implementing new rendering technique & auto tiling system
The current version terrain generator creates 10,000+ blocks within seconds with 4 layers & positions itself
using 4 Game Objects
I decided to further develop the prototype game I created while I was doing my first 100 Hour Workweek Challenge.
In the last two days of the challenge I developed a modular behavior & combat system using three divisions of character logic (Logic-Action-Movement)
& created some rudimentary pixel arts for the first main character and enemies.
I worked more on the game for several days of last week and created & implemented following items -
( keep in mind that all of this is in context of a beginner game developer -- starting from zero knowledge of C# scripting language and Unity’s API )
For following weeks I will continue to learn and implement new features from bottom up.
---------------------------
- added
flashing hit animation
- created
initial version
of player UI (HP)
- added
flashing death animation
- added
player attack functionality
- enemies now disappear
when their HP is 0
- added
character stun delay
when hit
- added
character knock back
- fixed the bug
where player sprite had
residual pixels
from other positions
- created
zombie sprite & animations
- added
zombie character & zombie AI
( now zombies & slimes will fight each other)
Finished Unity 2D Essential Training by Jesse Freeman
Finished Scripting Unity with C# by Kelley Hecker
Finished Project: 2D Roguelike Tutorial by Unity
Made 1 Demo Web Application
Made 2 Demo Unity Game
Designed & Created Original A.I. System for Unity
Since the beginning of the week I’ve learned -
Fundamental understanding of Ruby On Rails -- How to build a web application from scratch and securely deploy on the world wide web
Fundamental understanding of Unity2D -- How to use Unity’s framework to develop 2D games
Functional knowledge of C# programming language & Unity’s scripting API -- How to create modular A.I. with C# and MonoDevelop
How to create custom 2D sprites and animations with pixel art
Also I’ve learned much about productivity, value of time, and myself... which I will post of blog about soon.
And I’ll continue to log my progress on Web Development, Game Development, and more. If you read this and had any questions feel free to let me know!
-------
Web Development
Day 7
Ruby On Rails Tutorial
-------
41:15
added
micropost feed page
embedded in user page
42:16
made home page into
micropost posting page
for logged in users
42:42
Fully implemented
micropost creation
functionality
&
added micropost feed to
user page
43:05
* added micropost
validation to user page
43:25
added micropost
delete function
43:57
added picture uploader
44:32
* configured
micropost feed to
display resized image
[used CSS instead of
image resizing program]
45:03
Rails Tutorial
Ch. 11 Finished
45:04
The last chapter..!
46:31
learning about
data models linked by
employing
intermediary model
(following -
active & passive relationship -
follower)
47:17
learning about
advanced routing options
47:28
added
follower & following model and stats view
48:35
added
followers & following page
48:52
implemented
fully functional
follow & unfollow function
49:30
implemented
AJAX request for handling
follow & unfollow function
50:11
configured
homepage to show
user & following posts
&
applied rudimentary
SQL optimization for
better scaling
50:15
Created full feature
demo web application
50:27
Finished
Rails Tutorial Ch. 12
-
Finished
The Ruby on Rails Tutorial by Michael Hartl
-------
Game Development
Day 7
Adding Functionality
To Prototype Game
-------
43:35
learned how to set & use
Class properties
44:12
coded parts of first layer
of logic hierarchy
&
sent data to the
next layer
44:48
set up
target acquisition
45:32
reconfigured
unit sizes &
distance calculation
46:30
coded parts of
second and third layer
(action and movement)
&
linked all the layers
together to make all logic
in the hierarchy
conceptually functional
implemented
following logic
(slime)
1) logic
- Territorial
-- 1. no enemy
---- 2) action
------- chill out
---------3) movement
------------ move random
-- 2. enemy in sight
---- 2) action
------- aggression
--------- 1. in range
----------- 3) movement
------------- attack
--------- 2. out of range
----------- 3) movement
------------- move toward
46:48
coded
Movement_MoveTowardsTarget
Class and its functions
47:56
linked Movement Classes
to character animations
48:47
coded
Movement_Random
Class and its functions
49:07
Completed
modular Logic system
(logic-action-movement)
