You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
I have been programming for about 10 years. 3 of those years I have
been writing Ruby. Recently I have developed a deep interest in good
software design, appropriate levels of testing, and other
programming paradigms.
I am a consultant and (Ruby) instructor at Big Nerd Ranch.
I am one of a handful of nerds that who works remotely full-time. I
love working remotely, but it is not without its challenges! My wife
and I own a dance studio where she does the teaching/dancing, and I
greet the people. 😊
Fighting complexity in programming is hard. Every time we’re unsure
about a value, we add conditional statements that determine how we
proceed. These conditionals result in increased complexity and
decreased confidence in our system. If only we could become more
confident with the state of the system…
Hurrah! Data integrity can help build this confidence. By constraining
our data, we can make some assumptions about the state of the system
even as it grows in complexity. I'll explain why properly
constraining your data is important and show you how to practically
and intelligently add constraints to your data. I'll even toss in
some real world examples!
Gone are the days of guarding against potentially nil values. Out
with orphaned and duplicate records! Join me as we program with
confidence and integrity!
Abstract
Fighting complexity in programming is hard. When you're unsure
about a value, you add conditionals in turn increasing complexity
and eroding confidence. Data integrity restores lost confidence!
Gone are the days of guarding against potentially nil values. Out
with orphaned and duplicate records! Join me as we program with
confidence and integrity!
Details
The software we
write becomes legacy as soon as it is shipped. It is critical
that we develop habits that encourage the building of software that will stand
the test of time. A significant source of bugs in software is unexpected state.
Data integrity reduces the surface area of edges cases by enforcing certain
absolutes about the application's state. Data integrity is
one of many good habits that developers should master in order to increase
confidence in the software they create.
In this talk I make a case for why adding constraints to an application's
database makes it easier to reason about the state of the system. Avdi Grimm
refers to this as "confident programming". I really like the implication, and
it is especially important in the dynamic nature of Ruby. I will illustrate how
data integrity is introduced to a web application (using Rails as an example),
and why validations do not cut it as data integrity. The audience should leave
with an understanding of the difference in database constraints and data model
validations and when it is appropriate to use each. They should also be
provoked to consider implementing it in their applications.
Pitch
Data integrity is particularly close to home for me. I have been working on a
legacy application for about 2 years. The single largest source of bugs in the
application is data getting into unexpected state. Some of the data enters the
application via direct database insertions, so we can't vet it in application
code. This has created a deep conviction in me that as much constraint as
possible should be enforced at the data layer. The constraints that we've
introduced over time have without a doubt lead to fewer state-related bugs.
I am very excited for the opportunity to share this enthusiasm with the
Rails Conf attendees! Thank you for considering me for the conference.
As an instructor at Big Nerd Ranch, we run week-long "bootcamps" filled with
lectures and hands-on exercises. In addition to lecturing in class, I've had
opportunity to present a number of internal talks to team ranging from
technical to "softer" consultant-related subjects.
I have also been given the chance to speak publicly on a couple occasions:
It has been a personal goal for some time to break onto the conference scene.
Having attended Ancient City Ruby in 2013, I could hardly think of a better
event to make my debut! I am very (get it?) excited for the opportunity to
speak, and I appreciate the opportunity and consideration.
There are a lot of reasons I love Ruby. It makes me a happy
programmer. Apple recently released its latest programming language
into the wild, Swift. Swift is an object oriented-programming
language with a functional personality.
I will give you the whirlwind tour of what I have learned in my
dabbling with the language. We will compare constructs in Swift to
similar implementations in Ruby and contrast the differences. We’re
talking language and syntax here, the good stuff. No need to bring
your iOS or Cocoa chops 😉. Perhaps we have established a
trajectory to find happiness developing native applications as well?
I would be interested in hearing you talk on both of these topics! In fact, I thoroughly enjoyed your talk on Swift at NSHuntsville. :-)
Thoughts on Data Integrity Abstract
Little things:
"life" seems a bit over the top. I would just remove it.
"we add a conditions" should be "we add a condition" OR "we add conditions"
"Gone are the days of guarding potentially nil values." could be "Gone are the days of guarding against potentially nil values"
Bigger things:
The abstract is a bit hyperbolic, but I think it works. 😄
What is the value proposition of this Data Integrity talk? Your Swift description does a good job of conveying what I'm going to get out of it. Sell it to me - maybe with a mini-agenda/synopsis.
Here is my stab at bringing attention to the value prop. I may be completely off the mark with the tone/content:
Confident Programming with Integrity
Fighting complexity in programming is hard. Every time we’re unsure about a value, we add conditional statements that determine how we proceed. These conditionals result in increased complexity and decreased confidence in our system. If only we could become more confident with the state of the system…
Hurrah! Data integrity can give us this confidence. By constraining our data, we can make some assumptions about the state of the system even as it grows in complexity. I'll explain why properly constraining your data is important and show you how to practically and intelligently add constraints to your data. I'll even toss in some real world examples!
Gone are the days of guarding against potentially nil values. Out with orphaned and duplicate records! Join me as we program with confidence and integrity!
I think this first paragraph is good. My small rewrite (take this with a grain of salt) looks like:
As programmers, we fight complexity on a daily basis. Conditional statements are
a commonly implemented tool for fighting this complexity. However, they also
increase the complexity of the system. Every time we’re unsure about a value,
we add a condition to decide how to proceed. If only we could become more confident with the state of
the system…
I really like the title @strukturedkaos suggested. I suggest a tweak to it, Confident Programming with Data Integrity
The second paragraph doesn't seem well defined. Specifically, these two sentences can use a little work:
By constraining our data, we can make some assumptions about the state of the system. Gone are the
days of guarding potentially nil values. Out with orphaned and duplicate records!
re: "life". Maybe data is more akin to the "blood", but now it sounds scary :)
Swift
I think this one is well written and I don't see anything I would change.
Summary
If I had to choose a talk to attend, I would choose the 'Data Integrity' talk.
Not sure about "life" in the data integrity abstract. Better word, concept, idea for that?