SPOILER Did 90 Day Fiance's Danielle and Mohamed get married?
We’re only three episodes into the second season of TLC’s popular long-distance romance reality series 90 Day Fiance featuring , which give them 90 days to either marry their significant other, or pack their bags and head back home. As you might imagine, these relationships often cause friends and family members (and TV viewers) to question the motives of those who might just be in it for their green card, and no other Season 2 couple has raised more eyebrows than Danielle and Mohamed.
Here is the intro video to the couple:
In addition to their 15-year age difference (Danielle is 41, Mohamed 26), there is also the fact that Danielle has four kids — one of which is only five years younger than his potential new step-dad. Here’s a video clip in which Danielle and Mohamed discuss the first meeting between him and her oldest son:
Mohamed is from Tunisia and if you search for “” in Google images the results are a little disconcerting in that there are several featuring younger, Tunisian who have married women from other countries. The photos link to stories (mostly British) with headlines like:
Just for fun I tracked down Mohamed’s Facebook page, and here are a couple of his photos prior to taping 90 Day Fiance:
So, the big question is: Did Danielle and Mohamed get married?
******** SPOILER ALERT ********
During the K-1 visa application process, Danielle made several posts in an online forum for people going through the process, and she eventually spilled the beans on whether or not they got married (as well as some financial issues she was dealing with).
March 20, 2014 &# PM
My fiancee had his interview Feb 6. We are in administrative processing its been 6 weeks when we check website there has been a update every week. We both are getting frustrated we want to be together and start our life. Any else having same problem? How long can they keep you in adminstrative processing?
Forum Member
March 20, 2014 &# PM
Unfortunately, there is nothing that can be done. Just wait, the most hardest part! We are also in ap for 14 months now, so I can perfectly understand what you feel.
March 20, 2014 &# PM
[to forum member] Have you had any updates on your case. We have had 1 every week since Feb 6.
July 25, 2014 &# AM
We got married July 9 and we need to fill papers out for adjustment of staus, but I lost my job the end of May so we are having some fincial problems. How long can you wait to do the the adjustment of status paper work. Can you get fees waived?
Forum Member
July 25, 2014 &# PM
Fees are not waived, sorry. Ideally you should file as soon as possible which means being able to pay the applicable fees and possibly have a co-sponsor for the I-864 Affidavit of Support I-864.
August 19, 2014 &# PM
We got married July 9 and have had some money issues, is it ok for spouse to do odd jobs making some cash like mowing lawns or things like that to help get money for adjustment of status?
So there you have it! Danielle and Mohamed got married on July 9, which is verified by this online K-1 visa tracker:
UPDATE –
Just click the link to find out! Oh, and we’ve also !
And in case you were curious about the K-1 visa procedure (I know I was), here is some info from :
A K-1 visa is a visa issued to the fiancé or fiancée of a United States citizen to enter the United States. A K-1 visa requires a foreigner to marry his or her U.S. citizen petitioner within 90 days of entry. Once the couple marries, the foreign citizen can adjust status to become a lawful permanent resident of the United States (Green Card holder). Although a K-1 visa is legally classified as a non-immigrant visa, it usually leads to important immigration benefits and is therefore often processed by the Immigrant Visa section of United States embassies and consulates worldwide. If a K-1 visa holder does not marry his or her U.S. citizen petitioner within 90 days of entry, then he or she must depart the United States within 30 days.
The great majority of K-1 visas applied for are granted. In 2009, 95 percent of the K-1 visa applications were approved: out of 29,127 K-1 visas applied for, 27,678 were issued, and 1,449 refused, and 1,266 were waived/overcome.
Keep up with Danielle and Mohamed as well as the rest of the 90 Day Fiance Season 2 cast every Sunday night at 9/8c on TLC!
class="statcounter"
src="//af/"
alt="web analytics">
RELATED ARTICLES
Pingback: ()
Pingback: ()
Pingback: ()
Pingback: ()
Happy birthday Kylie!
Kylie Jenner’s 18th birthday is right around the corner, and the teenager is using it to cash in big time: she’s netting $200,000 to throw her party in Montreal. What’s the other big reason it’s important Kylie Jenner celebrates Canada-style? Read on to find out!
Drake vs Meek
The ongoing feud between Drake and Meek Mill feud continues as Drake releases a brand new track titled “Back to Back Freestyle” in which he goes off on Meek in a very unsubtle manner, although her never calls him out by name. Keep reading to listen to the track and read the full lyrics, which includes lines like “Yeah, trigger fingers turn to Twitter fingers” and in reference to Meek’s current tour and relationship with nicki Minaj, “Is that a world tour or your girl’s tour? I know that you gotta be a thug for her, This ain’t what she meant when she told you to open up more.”Boltmade | We Design and Build Software.
We’d like to give a warm welcome to Kathi Taylor, who’ll be joining Boltmade as our office manager.
Kathi has a background in math from the University of Waterloo. Since then, she’s been at a local consulting firm for 15 years as a jack-of-all-trades, and has done a stint in IT support at an insurance company.
Kathi is very involved in the Scouting group, and uses her top-notch baking skills to help fundraise. During her down time, Kathi likes to cook, read, knit, and hang out with her 2 kids, and 2 cats.
You can connect with Kathi on .
On July 15th, we’ll be prototyping using InVision.
is one of our favourite tools. It allows us to prototype, test, and send designs to clients for feedback.
Two of our designers,
will begin by introducing and discussing some basic features of InVision. Then they’ll be walking you through a typical workflow: uploading designs, linking them together to make an interactive prototype, and then sending the prototype to your mobile device. A question and answer period will be held after the tour.
You can find out more and sign up .
We hung out with a lot of neat people this month to talk about what we do and how we work.
That, along with welcoming a new member to the team and hosting KW’s biggest tech social, made for a busy month.
Welcome Chris
We welcomed Chris Fehrer to the Boltmade team this month. Chris is a graduate of McMaster University who will be joining our development team. We’re really excited to have him onboard!
We are continuing to look for excellent individuals to join us!
if you’re interested in working with us.
Ways We Work
Ways We Work interviews individuals and teams from a diverse range of industries to document how they work.
We had a great time hosting them. Thanks for the visit!
HackerNest
We had the pleasure of hosting June’s HackerNest, an event for tech communities to come together and meet one another. We had a great time reconnecting with old friends, and welcome new faces to the office.
Introduction to Functional Programming
This month we decided to re-run one of our original workshops on functional programming. In an exercise that builds up the fundamental concepts of functional programming, students were given a problem and the answer - but no instructions to recreate the solution. With the help of cheat sheets and mentors, everyone was able to get through the exercises using both Haskell and Scheme over the evening.
You can try the
out yourself using cheat sheets for
Functional programming workshop is off at
& ?Jesse? (@elsom25)
Design Sprint at uWaterloo
We partnered up with the Entrepreneurship Society at uWaterloo again this term to bring our Design Sprints in Practice workshop to students who are just starting to venture into building their own products.
. We’re always excited to bring workshops to more people in the area!
Upcoming Events
Make sure to
to receive early invitations to our workshops and events.
: We are partnering up with uWaterloo’s UX club to bring Jeff Patton’s story mapping workshop to students who are interested in learning about this method of organizing product features.
: Intersections celebrates pure mathematics, computer science, programming languages, and intersectional activities. This month they’ve invited , a Quantum Physicist and Roboticist du jour to walk them through the many ways you can build a quantum computer.
: We often use
as a tool to share concepts with clients to collect their feedback. In July,
will be demonstrating a few of their favorite aspects of InVision and create a prototype with the group.
: An event giving programmers and designers the opportunity to meet other creative people and learn from each other.
In case you missed it...
One of our UX designers, , was
on her experiences in runing successful kick-off sessions, understanding problems clients are trying to solve, and her strategies for getting clients to keep their ideas focused at Boltmade.
We recently started a few new projects and decided to try out some new technologies to help solve known problems we’ve run into in the past. Check out our thoughts on
for a front-end JavaScript project, and using
One of our teams at Boltmade started a new iOS project recently. We’ve built iOS apps before, and we decided that since we were building from scratch, this was a great opportunity to try to improve upon two major pain points from prior iOS projects:
Massive View Controllers: iOS’s UIViewController subclasses tend to become unwieldy beasts full of a mix of UI and business logic.
Testing: UIViewContoller subclasses contain most of the logic, so they should be tested, but testing code that’s intermixed with view code is difficult.
We decided to try tackling both of these problems by using
to bring a Model-View-ViewModel (MVVM) architectural approach to this project, which promised to reduce view controller code and decouple UI and business logic for easier testing.
Tools Used
because it is currently the recommended stable version. It was built for Objective-C so it doesn’t take advantage of a lot of Swifty goodness that
with . In the meantime, ReactiveCocoa needed some help working with Swift, so we took a mix of extensions and structs for RAC, RACObserve and a couple other handy tidbits like RACSignal.subscribeNextAs&T& from
and . We also added .
For testing, we used
and . Quick gives us a Spec-style testing framework in Swift, and Nimble gives us nicer expectation syntax.
Our Approach, By Example
MVVM means many things to many people. We are applying the concept similar to how it is used in Windows Presentation Foundation (WPF) to create a distinction between the view (and view controller), which deal with UI things, and some other thing that handles business logic, network code, etc. We call that other thing the view model. To get more familiar with the concept of MVVM on iOS and why you might want to use it, we recommend the following write-ups that helped us get started:
high-level explanation of the MVC problem on iOS and how it can be solved with MVVM, and
slightly more hands-on version using ReactiveCocoa.
To explain the way we used ReactiveCocoa and MVVM we’ll code the same application twice: once in a naive way placing all the logic within the view controller, and once in a ReactiveCocoa MVVM way. The simple app we’ll code is a dice rolling game: you have a die, and you can roll it. When you roll a 6, you win and the game is over. You have to start a new game to continue rolling the die. Here’s what it looks like.
First, let’s look at a naive implemenation of this game:
NaiveViewController.swift
import UIKit
class NaiveViewController : UIViewController {
@IBOutlet weak var currentRollLabel: UILabel!
@IBOutlet weak var rollButton: UIButton!
@IBOutlet weak var newGameButton: UIButton!
var die : Die?
override func viewDidLoad() {
super.viewDidLoad()
self.rollButton.addTarget(self, action: "rollButtonPressed", forControlEvents: .TouchUpInside)
self.newGameButton.addTarget(self, action: "newGameButtonPressed", forControlEvents: .TouchUpInside)
updateUIStates()
func updateCurrentRollLabel() {
switch self.die?.dieValue {
case .Some(DieValue.Six):
self.currentRollLabel.text = "YOU WIN! (Why don't you play again?)"
self.currentRollLabel.textColor = UIColor.greenColor()
case (.Some(let dieValue)):
self.currentRollLabel.text = "You rolled a \(dieValue.rawValue). Keep trying!"
self.currentRollLabel.textColor = UIColor.blackColor()
self.currentRollLabel.text = "You haven't rolled the die yet."
self.currentRollLabel.textColor = UIColor.blackColor()
func updateButtonState() {
self.rollButton.enabled = self.die?.dieValue != .Six
func updateUIStates() {
updateButtonState()
updateCurrentRollLabel()
func rollButtonPressed() {
if let die = self.die {
die.roll()
self.die = Die()
updateUIStates()
func newGameButtonPressed() {
self.die = nil
updateUIStates()
This is pretty straight forward: we have IBOutlets for a label that tells you about the game state, a button to roll, and a button to start a new game. There is a function that updates the UI state updateUIStates(), and targets on our buttons. Those targets manipulate the model object die, and then call updateUIStates() to ensure the UI is up to date.
What we don’t like about this implementation is the manual calls to updateUIStates() that happen when you modify the model. If we were to write additional game logic, we would likely have to similarly remember to update the UI, like we did in both rollButtonPressed() and newGameButtonPressed(). This also looks like it would be difficult to implement unit tests on because the tests would have to instantiate the view controller and interact with the view.
Let’s try again, but this time with ReactiveCocoa and MVVM:
MVVMViewController.swift
import UIKit
class MVVMViewController : UIViewController {
@IBOutlet weak var currentRollLabel: UILabel!
@IBOutlet weak var rollButton: UIButton!
@IBOutlet weak var newGameButton: UIButton!
var viewModel = ViewModel()
override func viewDidLoad() {
super.viewDidLoad()
RAC(self.currentRollLabel, "text") &~ RACObserve(self.viewModel, "currentRollDescription")
RAC(self.currentRollLabel, "textColor") &~ self.viewModel.isGameOver.mapAs { (isGameOver : Bool!) -& UIColor! in
return isGameOver == true ? UIColor.greenColor() : UIColor.blackColor()
self.rollButton.rac_command = self.viewModel.rollDieCommand
self.newGameButton.rac_command = self.viewModel.newGameCommand
Check out that tiny view controller! It still has the IBOutlets, and other than that its sole responsibilities are UI-related, which means binding the view to the view model. In a more complicated app it might also perform UIView animations, or create and configure an AVCaptureSession if you wanted to use the built-in device camera. The point is, it’s all strictly UI logic. So where does everything else go?
ViewModel.swift
import Foundation
import ReactiveCocoa
public class ViewModel : NSObject {
public dynamic private(set) var currentRollDescription : String! = nil
public private(set) var rollDieCommand:RACCommand!
public private(set) var newGameCommand:RACCommand!
public private(set) var isGameOver:RACSignal!
public dynamic private(set) var die : Die?
public override init() {
super.init()
RAC(self, "currentRollDescription") &~ RACObserveOptional(self, ["die", "dieValueRaw"]).mapAs { (dieValueRaw : Int?) -& String! in
switch (dieValueRaw) {
case .Some(DieValue.Six.rawValue):
return "YOU WIN! (Why don't you play again?)"
case .Some(let dieValueRaw):
return "You rolled a \(dieValueRaw). Keep trying!"
return "You haven't rolled the die yet"
self.isGameOver = RACObserveOptional(self, ["die", "dieValueRaw"]).mapAs { (dieValueRaw : Int?) -& Bool! in
switch (dieValueRaw) {
case .Some(DieValue.Six.rawValue):
return true
return false
self.rollDieCommand = RACCommand(enabled: isGameOver.not(), signalBlock: { (any:AnyObject!) -& RACSignal! in
if let die = self.die {
die.roll()
self.die = Die()
return RACSignal.empty()
self.newGameCommand = RACCommand(signalBlock: { (any:AnyObject!) -& RACSignal! in
self.die = nil
return RACSignal.empty()
In the view model we see the things that we bound the view to in the view controller: a couple of button commands, a descriptive string, and a signal that tells us when the game is over. The string currentRollDescriptionis itself bound to the private die member, so that it is always in sync with die. Then to start a new game, the newGameCommand simply throws out the current die. Notice that we don’t have to do any UI maintentance: currentRollDescription already knows that it needs to reflect the value of die at all times, so it does. In fact, notice that there is not even an import UIKit here: view models are strictly a no UI zone.
There’s a little bit more going on with rollDieCommand: if there’s a die it roll()s it, otherwise it creates and holds a Die() which rolls itself on creation, but either way the command is only enabled if isGameOver.not(). Like currentRollDescription, isGameOver is a RACSignal that reflects the current state of die: in this case, when dieValueRaw is 6, the game is over. This means that rollDieCommand is only enabled when the game hasn’t already be won.
ReactiveCocoa gives you a fancy extension on UIButton called rac_command which applies the enabled state of the command to UIButton.enabled, so you don’t even have to do any additional work to enable or disable rollButton: it behaves as you would expect based on the validity of its rac_command.
There’s also a bit of ugliness in that we have to RACObserve dieValueRaw instead of dieValue. The reason for this is that we coded dieValue as an enum. ReactiveCocoa can only work with types that can be translated to Objective-C, and Swift enums are more expressive than Objective-C enums so they aren’t compatible. The work-around is to keep the enum property dieValue, but add a didSet which changes something compatible with Objective-C and observe that when you need to use ReactiveCocoa. As example, here’s the model which provides an enum property dieValue and a matching Objective-C-compatible property dieValueRaw:
import Foundation
public enum DieValue: Int {
case One = 1, Two, Three, Four, Five, Six
public class Die : NSObject {
dynamic public private(set) var dieValueRaw : Int
public var dieValue : DieValue {
self.dieValueRaw = self.dieValue.rawValue
public override init() {
self.dieValue = Die.getRandomRoll()
self.dieValueRaw = self.dieValue.rawValue
super.init()
public func roll() {
self.dieValue = Die.getRandomRoll()
private class func getRandomRoll() -& DieValue {
var numVal = Int(arc4random_uniform(6)+1)
return DieValue(rawValue:numVal)!
Overall we like this approach better than the naive approach and the traditional MVC approach for a number of reasons. It reads and wri it encourages us to think in terms like “what should currentRollDescription be?”, then go code it to provide a single source of truth. We’ve also completely separated the UI from our business logic. This means that the UI could be changed or rebranded without fear of modifying our business logic. It also means that we could test our business logic without dealing with views. Let’s do that!
Testing: No Excuses Now
Now that we don’t need to deal with UIKit, testing is easy! Here’s just a couple of tests to demonstrate that useful tests are possible without ever instantiating a view or view controller.
ViewModelSpec.swift
import Quick
import Nimble
import SimpleDiceGame
class ViewModelSpec: QuickSpec {
override func spec() {
describe("rolling the die") {
var vm:ViewModel!
beforeEach {
vm = ViewModel()
it ("should create a die") {
vm.rollDieCommand.execute(nil)
expect(vm.die).toNot(beNil())
it ("shouldn't roll anymore once you win") {
var error : NSError? = nil
for var i = 0; (i & 40) && (vm.isGameOver.not().asynchronousFirstOrDefault(nil, success: nil, error: nil) as! Bool); i++ {
vm.rollDieCommand.execute(nil)
expect(error).to(beNil())
vm.rollDieCommand.execute(nil).asynchronousFirstOrDefault(nil, success: nil, error: &error)
expect(error).toNot(beNil())
it ("it should say you won when you win") {
var error : NSError? = nil
for var i = 0; (i & 40) && (vm.isGameOver.not().asynchronousFirstOrDefault(nil, success: nil, error: nil) as! Bool); i++ {
expect(vm.currentRollDescription).toNot(contain("WIN"))
vm.rollDieCommand.execute(nil)
expect(vm.currentRollDescription).to(contain("WIN"))
What we liked:
We accomplished what we set out to do: our view controllers are smaller than in past experiences and are very focused on UI logic and binding. Our new view models are decoupled, contain all the business and network logic and are better organized. We also have better test coverage.
We found decoupling of UI logic and business logic made collaboration better: it’s really quick and easy to review a pull request when you see a view model with a command like rollDieCommand: you don’t have to go hunting around to make sure all the edge cases are caught because the whole situation of rolling the die is described in that little piece.
We found the mental process of programming reactively really enjoyable: for example, in the past, we’ve naturally tended to think about things like the enabled state of a button (ex rollButton) by fully defining the situation in our heads, and then going and implementing that in all the places it’s necessary (ex on rollButtonPressed() and newGameButtonPressed() and who knows what other code in the future). Instead, we can now fully define the enabled state in isGameOver and attach it to the rollDieCommand, and now it’s done and we never have to think about it again. It’s just a really natural, confident way to think about code.
During the project we encountered a practical situation where we needed to represent the same data in two very different looking views. We had already built one of those views with a controller and view model. Turns out it was super quick and easy to build a new view and just attach it to the same view model. Decoupling achieved!
What we didn’t like:
As with most new technologies or programming strategies, the learning curve was pretty steep.
ReactiveCocoa 2.0 doesn’t play well with some of Swift’s nicer features, like expressive enums, generics and optionals. There are examples of each of these in ViewModel.swift above:
As , Swift enums aren’t supported. You can work around this with an Objective-C-compatible raw value.
Most of the RAC interfaces don’t leverage generics. We wrote RACStream.mapAs as a generics-friendly replacement for RACStream.map to avoid excessive casting.
extension RACStream {
func mapAs&T, U&(block:(T!) -& U!) -& RACSignal! {
var mappedStream = self.map { (any : AnyObject!) -& AnyObject! in
let inAsT = any as? T
return block(inAsT) as! AnyObject
return mappedStream as! RACSignal
Observing a property on an optional using RACObserve results in run-time errors. We made RACObserveOptional to handle situations like self.die?.dieValueRaw.
func RACObserveOptional(target: NSObject!, keyPaths: [String]) -& RACSignal
if (keyPaths.count == 0) {
return RACSignal.`return`(nil)
return RACObserve(target, keyPaths[0]).flattenMap { (any) -& RACStream! in
if let safeAny = any as? NSObject {
var restOfKeyPaths = keyPaths
restOfKeyPaths.removeAtIndex(0)
if restOfKeyPaths.count &= 2 {
return RACObserveOptional(safeAny, restOfKeyPaths)
return RACObserve(safeAny, restOfKeyPaths[0])
return RACSignal.`return`(nil)
ReactiveCocoa and UITableViews didn’t play as nicely as we would have liked. Table views have all those delegate and datasource methods you have to implement, which quickly cause your tidy view controller to expand in size. It’s not awful: people have come up with
to keep your view controller light, but we found the strategy broke down in table views with highly interactive cells. It wasn’t the end of the world, it was just clunky.
We had some brutal problems getting off the ground with Quick, Nimble and ReactiveCocoa due to some confusion with static vs dynamic library linking. More on that .
Conclusion
We loved taking an MVVM approach to iOS development. After an initial learning hump, ReactiveCocoa became easy to use, and the MVVM mental model allowed us to write code that read more naturally and was easier to maintain. We also liked having unit tests because, as intended, they sometimes caught bugs before we did. Overall it was a great experience and we’ll definitely take this approach again.
On June 24th, we’re bringing back one of our favorite workshops. Our own
will be leading a session on the basics of functional programming.
In this introductory workshop, we will going through the basic concepts around how to model and solve problems using functional programming. Specific methods that we will be demonstrating are folding, unfolding, map and filter. This workshop has been designed for developers who already has some experience with programming and would like to learn about other ways of solving problems.
You can find out more and sign up .
We’re excited to introduce Chris Feher to the Boltmade team this week.
Chris is a graduate of the Software Engineering program at McMaster University. There, he created games and interactive programs as part of the
team. Chris was most recently at a consulting company working with clients to build software applications.
Chris has many hipster hobbies. He does mountain unicycling, and is a YouTube partner. He collects watches, fountain pens, scotch, and board games. Chris also has 2 geckos, a tortoise, a salt-water nano reef, and a .
You can check out Chris’s , or his profile on .
One of our teams at Boltmade was recently tasked to build a front-end JavaScript application. There are
of frameworks to choose from, and while we have experience with many of these options, we decided to give Facebook’s React library a try on the merits of its simplicity and re-usability.
React Components
We found the strength of React to be in its use of dynamic, highly-modular components. Each component is a JavaScript class that models a particular view such as a drop-down or a navigation bar.
var ItemList = React.createClass({
getInitialState: function() {
{id: 1, name: "Option 1"},
{id: 2, name: "Option 2"}
removeItem: function(id) {
var updatedItems = this.state.items.filter(function(item))
return item.id !==
this.items.setState({items: updatedItems});
render: function() {
var items = this.state.items.map(function(item) {
&ItemEntry entry={item} removeItem={this.removeItem}/&
var ItemEntry = React.createClass({
render: function() {
&div className="item" item-id={this.props.item.id} onClick={this.clickRemove}&
{this.props.item.name}
clickRemove: function(e) {
this.props.removeItem(e.target.getAttribute('item-id'));
Components have state and property variables that can be accessed using this.state and this.props. A component’s state consists of mutable data that it can set and change. If a parent component needs to make a child component aware of its state, the parent can pass down this data as immutable properties to its children.
React is set up for a one-way flow of data down a structured tree of components. Only one component takes ownership of state data. In our example we are giving each ItemEntry an item property from its parent’s state that will be accessible to the child.
Updating State
Since data is only communicated in a single direction, from parent to child, it is the responsibility of the component that owns the state data to perform an update. React has its own cross-browser event system for capturing and responding to events. React’s synthetic events are W3C compliant and as a benefit of this, even older browsers like IE8 have access to many HTML5 events.
The best way to demonstrate this event handling in action is to look at what happens when a component informs its parent that it needs to update.
When an ItemEntry component is clicked, it triggers the onClick event that fires its removeItem handler. This handler, calls the parent removeItem method that was passed down to the ItemEntry as a function reference property. Once the state is updated in the parent component, all of the parent and child views must re-render to reflect this change.
To accomplish this, React uses an in-memory virtual DOM to efficiently modify its views whenever a component’s state changes. Components have a render method that returns a description of the new state of the DOM. It creates a new virtual DOM subtree which it diffs with the old virtual DOM to determine the minimal set of changes that need to be executed. It then finally interacts with the actual DOM and quickly updates it to reflect these changes.
JSX Syntax
In our render method we are using React’s XML-like JavaScript syntax extension called JSX to structure the view. JSX allowed us to mix HTML elements and React components in a structured hierarchy. In our example above we are using
the ItemEntry React component within the item list HTML container. While JSX is completely optional for using React, we found it useful in describing our views.
React has an
for JSX that they suggest to turn JSX into native JavaScript for development mode. In production, we use a
to prepare all of our JS ahead of time.
There is also an excellent Google Chrome extension, React Developer Tools, that adds a new React tab to your dev tools for inspecting React components directly and accessing their state and properties.
Component Lifecycle
React components have built-in functions that are triggered at specific moments in a component’s lifecycle.
componentWillMount and componentDidMount offer hooks to make any changes before and after a component is first rendered.
componentWillUpdate and componentDidUpdate are similar methods used to respond to a change in a component’s state, and or properties both before and after it re-renders.
If for some reason a component should not re-render when its state or properties change, then there is another lifecycle hook componentShouldUpdate that will conditionally allow or prevent a re-render of the component based on the boolean return value of the method.
We were very pleased with our results using React. It allowed us to create lightweight views that separated our UI into a logical structure of components. The speed and ease of React’s system of rendering eliminated nearly all of our direct DOM manipulation.
Having never used React before, we never encountered any major stumbling blocks as we became familiar with the library and it was very easy to pick-up.
React is definitely a library that we will keep in our toolbox for future projects.
This month, we onboarded many new friends, and worked on internal sharing at Boltmade. Check out what we did, and some events coming up next month!
Welcome Anton, Austin, Sean and Dan
This month we welcomed our Spring term coops. We had , , , and long-time returner, , join the team.
We’re also actively hiring for full-time developers. If you’re interested in Boltmade, !
Introduction to User Story Mapping
Mark Connolly run the Boltmade Session this month on user story mapping, based on Jeff Patton’s book: . For this session, attendees were split into teams, and asked to create a story map that reflected their morning routine from the moment they woke up to when they left the house.
I love a workshop that exceeds your expectations - thanks
& Alex Kinsella (@alexkinsella)
Our next Boltmade Session will be focused on functional programming on June 25th. You can sign up to our
to get early signup notifications!
Internal Knowledge Sharing
One of the coolest things about working at Boltmade is the exposure to multitudes of project types, new technologies, and other people who are great at what they do. We recently had a discussion on how to better share new knowledge amongst the team.
We are now starting to attend each other’s project sprint plannings. Its the best place to take a sneak peek into technical experiments for discussion later, and learn about how other projects organize themselves. It can also provide the project team with a fresh pair of eyes, and suggestions on how they can run things differently.
Upcoming Events
Make sure to
to receive early invitations to our workshops and events.
: We will be hosting June’s HackerNest meetup at our office! HackerNest socials are a fun, relaxed way to connect with your local tech community. All are welcomed!
: Intersections celebrates pure mathematics, computer science, programming languages, and intersectional activities. For June, Steven Taschuk will be presenting a talk on “A Few Species of Logic”, and the group will be discussing a paper by Philip Wadler, “Propositions as Types”.
: We are partnering up with the Entrepreneurship Society at the University of Waterloo again to bring them our design sprint workshop, based on Google Venture’s Design Sprint methodologies.
: Ralph Janke is going to give the group an introduction to using Cucumber for doing Behaviour Driven Development (BDD).
: We are bringing back our very first programming workshop on functional programming this month. We will be going through the basic concepts around how to model and solve problems using functional. Specific methods we’ll be going through include folding, unfolding, map, and filter.
: An event giving programmers and designers the opportunity to meet other creative people and learn from each other.
Today, we welcome Sean Amadio to Boltmade as our newest coop!
Sean is a Computer Engineering student from the University of Waterloo. Sean started programming at a young age with his brother, they created , a solitaire game designed exclusively for iOS7. Sean also created , a library that allows you to create animation on web and mobile without going fullscreen.
After work, Sean can be found in the wild either playing basketball, frisbee, or hiking in the Adirondacks. Sean will also be
our office warming party.
You can find more of Sean through his , because he doesn’t have Twitter - yet.
We would like to welcome Austin Park to the team today as our latest coop.
Austin is currently enrolled in the Software Engineering program at uWaterloo. He wrote his
when he was 12, enabling RPG Maker XP for multi-player support. More recently, Austin has been building iOS apps such as , an app that allows you to stream music libraries from nearby iOS devices, and , a multiplayer card game built using the new .
On his offtime, Austin likes , and watching TV. You can find Austin on , , or .
We’re hiring at Boltmade. If you’re interested,
AboutBoltmadeBoltmade is a web + mobile design and development shop based in Waterloo, Canada.Categories