The document discusses the development and features of a MongoDB Java driver, highlighting the importance of backwards compatibility, separation of concerns, and usability improvements. It covers various programming aspects such as API usability, testing challenges, and the integration of new technologies like Java 8 features. The presentation emphasizes best practices for documentation, code maintenance, and testing strategies while encouraging developers to engage with the new driver.

1. Trisha Gee, Java Driver Developer
#JFokus
What do you mean,
Backwards Compatibility?
@trisha_gee

2. Trisha Gee, Java Driver Developer
#JFokus
Stuff I Should Have Already
Known
@trisha_gee

4. customer = {
_id: "joe",
name: "Joe Bookreader",
address: {
street: "123 Fake St",
city: "Faketon",
state: "MA",
zip: 12345
}
books: [ 27464, 747854, ...]
}

5. Replica Set

7. MongoDB

8. MongoDB
NoSQL
Sharding
Replica Sets
Document Database
Scalable
Dynamic Schema
Strong
Consistency
Schema Design

9. MongoDB
NoSQL
Sharding
Replica Sets
Document Database
Scalable
Dynamic Schema
Strong
Consistency
Schema Design
The shell
Map reduce
MMS
Backup
Aggregation Framework

10. MongoDB
NoSQL
Python
Perl
PHP
Ruby
Node.js
C#
Java
Sharding
Replica Sets
Document Database
Scalable
Dynamic Schema
Strong
Consistency
Schema Design
The shell
Map reduce
MMS
Backup
Aggregation Framework
Scala
C
C++Go
Erlang
Python
JavaScript

11. The Java Driver

15. Te>
xt
Te>
xt
What do you want
to do?
_

16. Te>
xt
Te>
xt
What do you want
to do?
_

17. Common Problems

18. Our Solutions

19. ...not unique to us

20. which is the point

21. really.

22. “Let me help you
with that”

23. We’re using different
words

24. Or the same words to
mean different things

25. Ubiquitous Language

26. UML

28. Documentation

31. Your API is your UI

32. Naming is Hard

33. This takes ages...

34. DO THIS FIRST

35. The code is hard to
debug and modify

36. Re-write the whole
driver

37. Re-write the whole
driver

38. Anti Corruption
Layer

39. Instead of this...

40. Separation of
Concerns

41. Pluggable APIs

42. Backwards Compatible

43. Scala Support

44. Support other
libraries

46. Easier to maintain

47. Confusing API

48. Method Overloading

50. Update

51. Update

52. Update
collection.update(query, newValues);

53. Update

54. Update
collection.update(query, newValues);
collection.update(query, newValues, false, false, JOURNALED);

55. DSL-ish

56. Update

57. Update
collection.update(query, newValues);

58. Update
collection.update(query, newValues);
collection.find(query).updateOne(newValues);

59. Update
collection.update(query, newValues);
collection.find(query).updateOne(newValues);

60. Update

61. Update
collection.update(query, newValues);
collection.find(query).updateOne(newValues);
collection.find(query)
.withWriteConcern(JOURNALED)
.updateOne(newValues);

62. Update
collection.update(query, newValues);
collection.find(query).updateOne(newValues);
collection.find(query)
.withWriteConcern(JOURNALED)
.updateOne(newValues);
collection.update(query, newValues, false, false, JOURNALED);

63. Self Documenting

64. IDE-friendly

65. Fewer choices

66. Ctrl + space

67. Testing is Hard and
Boring

68. ...and we can’t agree
on style

69. BDD-ish
@Test
public void shouldIgnoreCaseWhenCheckingIfACollectionExists() {
// Given
database.getCollection("foo1").drop();
assertFalse(database.collectionExists("foo1"));
// When
database.createCollection("foo1", new BasicDBObject());
// Then
assertTrue(database.collectionExists("foo1"));
assertTrue(database.collectionExists("FOO1"));
assertTrue(database.collectionExists("fOo1"));
// Finally
database.getCollection("foo1").drop();
}

70. vs

71. @Test
public void testInvalid() throws UnknownHostException {
try {
new DBAddress(null);
fail();
} catch (NullPointerException e) { // NOPMD
// all good
}
try {
new DBAddress(" tn");
fail();
} catch (IllegalArgumentException e) { // NOPMD
// all good
}
}

72. ...and the tests are
confusing

73. @Test
public void testMaxScan() {
countResults(new DBCursor(collection,
new BasicDBObject(),
new BasicDBObject(),
primary())
.addSpecial("$maxScan", 4), 4);
countResults(new DBCursor(collection,
new BasicDBObject(),
new BasicDBObject(),
primary())
.maxScan(4), 4);
}

74. Spock!

75. def 'should throw duplicate key when response has a duplicate key
error code'() {
given:
def commandResult = new CommandResult(new ServerAddress(),
['ok' : 1,
'err' : 'E11000',
'code': 11000] as Document,
1);
when:
ProtocolHelper.getWriteResult(commandResult)
then:
def e = thrown(MongoDuplicateKeyException)
e.getErrorCode() == 11000
}

76. Really? Groovy?

77. Our tests are our
documentation

78. BDD-ish thinking

79. Test styles
converging

80. Data Driven Testing
def '#wc should return write concern document #commandDocument'()
{
expect:
wc.asDocument() == commandDocument;
where:
wc | commandDocument
WriteConcern.ACKNOWLEDGED | ['w' : 1]
WriteConcern.JOURNALED | ['w' : 1, 'j': true]
WriteConcern.FSYNCED | ['w' : 1, 'fsync': true]
new WriteConcern('majority') | ['w': 'majority']
new WriteConcern(2, 100) | ['w' : 2, 'wtimeout': 100]
}

81. Data Driven Testing
def '#wc should return write concern document #commandDocument'()
{
expect:
wc.asDocument() == commandDocument;
where:
wc | commandDocument
WriteConcern.ACKNOWLEDGED | ['w' : 1]
WriteConcern.JOURNALED | ['w' : 1, 'j': true]
WriteConcern.FSYNCED | ['w' : 1, 'fsync': true]
new WriteConcern('majority') | ['w': 'majority']
new WriteConcern(2, 100) | ['w' : 2, 'wtimeout': 100]
}
is.gd/ddTest

82. Lesser Evil
def 'should throw IllegalArgumentException when required
parameter is not supplied for challenge-response'() {
when:
MongoCredential.createMongoCRCredential(null, 'test', ...);
then:
thrown(IllegalArgumentException)
when:
MongoCredential.createMongoCRCredential('user', null, ...);
then:
thrown(IllegalArgumentException)
when:
MongoCredential.createMongoCRCredential('user', 'test', ...);
then:
thrown(IllegalArgumentException)
}

83. Java 8 is coming

84. Lambdas

85. New Collections API

86. Date & Time

87. ...and other stuff

88. But we support 1.5

89. But we support 1.5

90. But we support 1.6

91. Do Your Homework

92. Single Method
Interfaces

93. External Iteration
DBObject query = new BasicDBObject("name", theNameToFind);
DBCursor results = collection.find(query);
for (DBObject dbObject : results) {
// do stuff with each result
}

94. Anonymous Inner Classes
Document query = new Document("name", theNameToFind);
collection.find(query).forEach(new Block<Document>() {
public boolean run(Document document) {
// do stuff with each result
}
});

95. Lambdas!
Document query = new Document("name", theNameToFind);
collection.find(query).forEach(document -> {
// do stuff with each result
});

96. API supports
lambdas

97. (Mongo) Collection
API Java 8-ish

98. Separation of
Concerns

99. Pluggable Codecs

100. Decoding
MongoCollection<Document> collection =
database.getCollection("coll");
Document query = new Document("name", theNameToFind);
Document result = collection.find(query).getOne();
Document addressDocument = (Document)result.get("address");
Customer customer = new Customer(result.getString("name"),
new Address(addressDocument.getString("street"),
addressDocument.getString("city"),
addressDocument.getString("state"),
addressDocument.getInteger("zip")),
(List<Document>) result.get("books"));

101. Decoding
MongoCollection<Document> collection =
database.getCollection("coll");
Document query = new Document("name", theNameToFind);
Document result = collection.find(query).getOne();
Document addressDocument = (Document)result.get("address");
Customer customer = new Customer(result.getString("name"),
new Address(addressDocument.getString("street"),
addressDocument.getString("city"),
addressDocument.getString("state"),
addressDocument.getInteger("zip")),
(List<Document>) result.get("books"));

102. Custom Codecs
MongoCollection<Customer> collection =
database.getCollection("coll", new CustomerCodec());
Document query = new Document("name", theNameToFind);
Customer customer = collection.find(query).getOne();

103. Now With Generics!

104. Separation of concerns
MongoCollection<Customer> collection =
database.getCollection("coll", new CustomerCodec());
Document query = new Document("name", theNameToFind);
Customer customer = collection.find(query).getOne();

105. Decoding code in
one place

106. Can support new
Date & Time

107. Caveat: Under
Construction

108. Unfinished Business

109. Codecs

110. New Public API

111. Clear testing
definitions

112. Continuous Delivery

113. The Driver!!!

114. Lessons Learnt

115. It’s been done
before:

116. Domain Driven
Design

117. Separation of
Concerns

118. The API is your UI

119. The tools exist

120. Don’t wait for Java 8

121. What’s in it for you?

122. Try This At Home

123. Try This At Work

124. Download & use the
new MongoDB driver

125. is.gd/java3mongodb

126. Come play

127. http://is.gd/java3mongodb
#JFokus
Questions
@trisha_gee

128. I want to run the
tests

129. Every time before I
check in

130. I want good quality
pull requests

131. I want it to be easy
for people to start

132. If it can be
automated, do it

133. Gradle

134. Painless Dependency
Management

135. Easy to introduce
static analysis

136. Wrapper = no extra
overhead

137. Easy to get started
as a contributor

138. Includes IDE Setup

139. Performance
Bottlenecks

140. More Servers =
More Delay

151. Event Driven

156. Async = Good

157. Events = Good

158. Scalable