Skip to content

Feed aggregator

Early Impressions of Kotlin

Mistaeks I Hav Made - Nat Pryce - Thu, 12/31/2015 - 01:07
We’ve been using the Kotlin programming language for a few weeks on our latest project to perform technical experiments, explore the problem space, and write a few HTTP services. I’ve also ported Hamcrest to Kotlin, as HamKrest, to help us write tests, and written a small library for type safe configuration of our services. Why Kotlin? The organisation I’m working with has mature infrastructure for deploying JVM services in their internal PaaS cloud. They use a mix of Java and Scala but have found Scala builds too slow. Watching my colleague struggle to use Java 8 streams to write what should have been basic functional map-and-fold code, I decided to have a look at some other “post-Java” JVM languages. We wanted a typed language. We wanted language aware editing. And we wanted a language that had an organisation behind its development and enough people using it that we could get questions answered, even the stupid ones we’d be likely to ask while learning. That eliminated dynamically typed languages (Groovy, JavaScript, Clojure) and languages that are less popular or have small, informal development teams behind them (Xtend, Gosu, Fantom, Frege, etc.). In the end it came down to Red Hat’s Ceylon and JetBrains’ Kotlin. Of the two, Ceylon is the most innovative, and therefore (to me, anyway) the most interesting, but Kotlin met more of our criteria. Kotlin has a more active community, is being used for commercial development by JetBrains and a number of other companies1, has good editing support within IntelliJ, has an active community on social media, and promises easy interop with existing Java libraries. Good points Kotlin was very quick to learn. Kotlin is a conservative increment to Java that smooths off a lot of Java’s rough edges. Kotlin is small and regular, with few special cases and gotchas to learn. In many ways it feels a bit like a compiled, typed Python with curly brace syntax. The type system is a breath of fresh air compared to Java. Type inferencing makes code less cluttered. There is no distinction between primitive & reference types. Generics and subtyping work together far better than Java: the type system uses declaration site variance, not use site variance, and variance does not usually have to be specified at all for functions. You never have unavoidable compiler warnings, as you do with Java’s type system. Functional programming is more convenient in Kotlin than Java. You can define free-standing functions and constants at the top level of a module, instead of having to define them in a “Utils” class. Function definitions can be nested. There is language support for immutable value types (aka “data classes”) and algebraic data types (“sealed classes”). Null safety is enforced by the type system and variables and fields are non-nullable by default. The language defines standard function types and a lambda syntax for anonymous functions. You can define extension methods on existing types. They are only syntactic sugar for free-standing functions, but nevertheless can lead to more concise, expressive code. The Kotlin standard library defines a number of useful extension methods, especially on the Iterable and String types. Kotlin supports, and carefully controls, operator overloading. You can overload operators that act as functions (e.g. arithmetic, comparison, function call) but not those that perform flow control (e.g. short-cut logical operators). You cannot define your own operators, which will stop me going down the rabbit hole of “ascii-art programming”, which I found hard to resist when writing Scala. Class definitions require a lot less boilerplate than in Java. Using old fashioned getter-and-setter style Java code is made more convenient by language support for bean properties. Anonymous extension methods (borrowed from Groovy, I believe) make domain specific embedded languages easier to write. Method chaining builder APIs are unnecessary in Kotlin and more awkward than using the apply function to set properties of an object. Kotlin has a philosophy of preferring behaviour to be explicitly specified. For example, there is no automatic coercion between numeric types, even from low to high precision. That means you have to explicitly convert from Int to Long, for example. I like that, but I expect some people will find it annoying. Surprises I didn’t miss destructuring pattern match Kotlin doesn’t have destructuring pattern match & language support for tuples. A limited form of destructuring can be used in for loops and assignments. The when expression is an alternative conditional expression that doesn’t do destructuring. I was surprised to find that I didn’t really miss destructuring. Without tuples you have to use data classes with named fields. The flow-sensitive typing then works rather well where destructuring would be necessary in a language where the type system is not flow-sensitive. For example: sealed class Result { class Success(val value: T) : Result() class Failure(val exception: Throwable): Result() } ... val e : Result = doSomething() if (e is Result.Success) { // e is known to be a Result.Success and // can be used as such without a downcast println(e.value) } Sealed classes cannot be data classes An algebraic data type cannot be be a data class, so you have to write equals, hashCode, etc. yourself. This is a surprising omission, since I always want an algebraic data type to be a value type. The Kotlin developers say that this will be fixed after version 1.0 is released. Functions are not quite first-class objects There’s a difference between f1 and f2 below: val f1 = {i:Int -> i+1} fun f2(i:Int) = i + 1 Code can refer to the value of f1 directly, but must use the “::” operator to obtain a reference to f2: val f = ::f2 Null safe operators push me to write more extension functions The null safe operators (?. and ?:) only help when dereferencing a nullable reference. When you have a nullable reference and want to pass a value (if it exists) to a function as a parameter, you have to use the awkward construct: nullableThing?.let{ thing -> fn(thing, other, parameters) } I find myself refactoring my functions to extension functions to reduce the syntactic noise, letting me rewrite the code above as: nullableThing?.fn(other, parameters) Is that a good thing? I’m not sure. Sometimes it feels a little forced. Companion objects Kotlin borrows the concept of companion objects from Scala. Why can’t classes be objects? Perhaps it’s a limitation of the JVM but compared to, say, Python, it feels clunky. Frustrations I only have a couple of frustrations with Kotlin. Lack of polymorphism Operators and the for loop are syntactic sugar that desugar to method calls. The methods are invoked statically and structurally — the target does not need to implement an interface that defines the method. For example, a + b desugars to a.add(b). However, there’s no way to write a generic function that sums its parameters, because add is not defined on an interface that can be used as an upper bound. There’s no way to define the following function for any type that has an add operator method. fun sum(T first, T second) : T = first + second You would have to define overloads for different types, but then wouldn’t be able to call sum within a generic function. fun sum(first: Int, second: Int) = first + second fun sum(first: Long, second: Long) = first + second fun sum(first: Double, second: Double)= first + second fun sub(first: Matrix, second: Matrix)= first + second fun sum(first: Money, second: Money)= first + second ... That kind of duplication is what generics are meant to avoid! Extension methods are also statically bound. That means you cannot write a generic function that calls an extension method on the value of a type parameter. For example, the standard library defines the same extension methods on unrelated types — forEach, map, flatMap, fold, etc. But there is no concept of, for example, “mappable” or “foldable”. Nor is there a way of defining such a concept and applying it to existing types to allow you to write generic functions over unrelated types. Kotlin doesn’t have higher kinded types that would let you express this kind of generic function or type classes that would let you add polymorphism without modifying existing type definitions. Compared to Rust’s traits, which support extension methods, operator overloading, type classes for parametric polymorphism, and interfaces for subtype polymorphism, Kotlin’s monomorphic extension methods and operator overloading are quite limited and do not help refactor duplicated logic. However, for typical monomorphic, procedural Java code this is probably not an issue. Optionality is a Special Case Kotlin’s support for nullable types is implemented by a special case in the type system and special case operators that only apply to nullable references. The operators do not desugar to methods that can be implemented for other types. For example, optionalThing?.foo can be considered a map of the function {thing -> thing.foo} over the option optionalThing. If foo itself is nullable, then it can be considered a flatMap. But the expressions do not desugar to map and flatMap And if you want to map or flatMap a function, you have to use a different syntax: optionalThing?.let(theFunction). For typical Java code, which is monomorphic and uses null references with wild abandon, language support for nullability is invaluable. But I would find it more convenient if it could be used polymorphically, or if Kotlin used a common naming convention for optional and other functor types. Null safety is not enforced when you interop with Java code. And you do that a lot. Kotlin doesn’t have many libraries or much of a runtime and makes it easy to call existing Java libraries directly. Kotlin expects you to know what you’re doing with respect to null references when calling Java code, and doesn’t force you to treat every value returned from Java as nullable. As a result, null safety is a bit of an illusion in a lot of our Kotlin code and it has come back to bite us. Conclusion The code we’ve been writing has been a mix of coordinating and piping data between existing Java libraries – Apache HTTP client, Undertow HTTP server, JDBC, Sesame, JSON and XML parsers, and so on – and algorithmic code that analyses human readable text. For that kind of work, Kotlin has been very useful. The Kotlin code is far more concise than the equivalent Java. In our domain models and algorithmic code, Kotlin’s type safety and especially null safety, has been a big help. Exactly how happy we’ve been with Kotlin has depended on the design style of the code we’re writing: For functional programming, Kotlin has occasionally been frustrating, because we cannot use parametric polymorphism to factor out duplicated logic as much as we’d like. For object-oriented programming, Kotlin’s concise syntax for class definitions and language support for delegation avoids a lot of Java’s boilerplate. However, most Java out there is monomorphic, procedural code moving data between “NOJOs” and APIs that expect objects to have “bean” getters and setters. Kotlin has made working with that kind of API much easier and far more concise than doing so in Java. As far as I can tell, RedHat sponsor development of Ceylon but do not actually use it to develop their own products. If I’m wrong, please let me know in the comments.↩
Categories: Blogs

Want to Write Non-Fiction Better?

Johanna Rothman - Wed, 12/30/2015 - 18:44

If you write as part of your job, I have a new online workshop starting in March. It’s Writing Workshop 1: Write Non-Fiction to Enhance Your Business and Reputation.

Here’s the problem I see. You’re a consultant or other entrepreneur. You know you need to write to enhance or build your reputation. You see a blank page (paper or screen), and you have no idea what to write. Maybe you can start, but you get 23 words in and get stuck. Maybe you get 5,000 words in, and you know there’s good work in there, but you can’t see it.

If you would like to address these challenges (and more), and deliver non-fiction articles, blog posts or newsletters to your readers, this workshop is for you.

You’ll learn:

  • How to make writing a habit.
  • How to structure an article that people want to read.
  • Write articles or blog posts or whatever that engage your ideal reader and build your reputation.
  • What writing is. What editing is. How they are different.
  • How to decide when to place your writing where.

You will write during this workshop. We will focus on short non-fiction, such as blog posts and articles.

I am the only person who will read your writing. I have published over 500 articles and well over 1500 blog posts. I write two columns each month and two quarterly columns each year. (If you have ever been part of a critique group, you know sometimes they savage you with feedback. I won’t do that.) I am a professional technical editor, as well as a writer.

I am focusing this workshop for people who know that writing will enhance their professional prospects, who have trouble publishing finished work. You will learn many ways to structure your work and publish. If you do the homework, you can expect that you will finish at least one article, as part of this workshop.

Want to join us? See Writing Workshop 1: Write Non-Fiction to Enhance Your Business and Reputation for full details and signup.

Categories: Blogs

Introducing Dr. Raymond Boehm, the Agile Estimator

Agile Estimator - Wed, 12/30/2015 - 18:14

AgileEstimator

The agile estimator blog is focused on estimating agile software development projects. Occasionally, it may stray into estimating in general. Likewise, it may talk about agile software development in general.

It is primarily moderated by Ray Boehm. He has the following qualifications:

  • Academically, he has an M.B.A. in finance and a Doctor of Professional Studies in computing. His thesis was “An Approach to Early Lifecycle Estimating for Agile Projects.”
  • Experientially, he has been involved in software development since the seventies. In the eighties, his focus became methodology, estimating, sizing and quality assurance. In 2003, he became involved in agile development when he started work on his doctorate. Since then, he has continued to be involved in the sizing and estimating of agile development projects.
  • Regarding certifications, he is an IFPUG Certified Function Point Specialist (CFPS) Fellow and a Certified SNAP Practitioner (CSP). He is also a Quality Assurance Institute (QAI) Certified Software Quality Analyst (CSQA)
Categories: Blogs

Running a Personal Retrospective for 2015

thekua.com@work - Wed, 12/30/2015 - 13:59

It’s the end of yet another year and a great time to reflect and put your Personal Retrospective hats on. I mention using Personal Retrospectives in my book, “The Retrospective Handbook: A guide for agile teams” because I find them powerful tools to celebrate the past year and to establish new goals for a new year.

This year, instead of simply stepping through questions on paper or on the computer, I decided to use sticky notes and activities I would use with a larger group. In order to keep flow, I wanted to prepare appropriately. This meant I:

  1. Made a plan for the exercises I wanted to run;
  2. Prepared the activities in advance so I could focus on gathering data/generating insights and reflecting instead of thinking about the process;
  3. Had a set of questions prepared in case I got stuck;
  4. Put on some background music – a quick search on YouTube found this spiritual landscape music; and
  5. Had water and coffee ready so I didn’t need to leave the room.

Here are the activities I used this year and that you might find useful for your own Personal Retrospective.

A year in tweets

Using very small stickies to simulate the 140 character limit (I’m guessing I had ~50) trying to generate a number of small tweets about how I felt about 2015.

 A year in reviewPersonal Retrospective Activity: A year in review Generating a timeline of events

I find the timeline a very powerful way to reflect on the year’s events, and to celebrate their significance. I first brainstormed memorable events before I attempted to nest them into the timeline. I the checked my personal and work calendars, realising that the human memory (or maybe it’s just mine!) is quite bad at remembering the order of events.

I found this blog, my twitter stream and my slideshare page useful sources to remember other significant events.

 TimelinePersonal Retrospective Activity: Timeline

Constructing the timeline took the most time of all exercises. Partly because there were lots of significant events for me, and I wanted to appreciate how much had occurred in this year.

4 L’s (Liked, Loved, Lacked, Longed For

I don’t normally use the 4 L’s exercise but figured I would give it a go. It seemed to work well in terms of framing insights but I found I needed to reflect deeper in some of the initial ideas I wrote up. Having an independent coach/facilitator would have been useful but I had to play this role myself.

 4LsPersonal Retrospective Activity: 4Ls Goals for 2016

After looking back at the timeline, and reflecting on how the events made me feel and what impact they had, I brainstormed some goals for this year. My focus for this first round was to generate all possible goals I might have, even though these long term goals would not meet the SMART criteria.

 Goals (Before Actions)Personal Retrospective Activity: Goals (Before Actions)

In the second round, I went through each of the different goals, generating some concrete next steps to move me towards each of those goals. My intention is to revisit the goals throughout the year and to take other actions to progress them further. The orange-coloured stickies in the picture below represet these next steps linked to the relevant goals (in green).

 Goals (Next Step Actions)Personal Retrospective Activity: Goals (Next Step Actions)

I also spent the time digitising the outputs into a A3 Personal Retrospective report and have made the template available here if you want to print it instead.

Have you set aside time to reflect on 2015? How did you run your Personal Retrospective? Leave a comment and let me know.

If you liked this post, you might be interested in The Retrospective Handbook: A guide for agile teams, also available in print.

Categories: Blogs

Lightning Talks at #AgileTD

Growing Agile - Tue, 12/29/2015 - 10:39
I had the absolute privilege of attending the lightning talk sessions at Agile Testing Days. This is not something I usually go to, but Concetta (my wife) was giving her first talk, so I went along. I was blown away by the great talks and ideas I got – and all in less than an hour! […]
Categories: Companies

Scrum Master Resolutions (2016 Edition)

Illustrated Agile - Len Lagestee - Mon, 12/28/2015 - 19:15

It is hard to believe 2015 is almost over and it’s even harder for me to believe that this blog has been around long enough to have a Scrum Master resolution post for the 5th year in a row. In case you’ve missed any of them here are the four earlier New Year resolution posts.

2012
2013
2014
2015

If there is a theme for the resolutions this year it would be “evolving the role.” Having been involved with many organizations as they attempt to improve and transform I am recognizing how much more is required from all roles, but especially Scrum Masters and Agile Coaches.

The call to all of you heading into the new year is to challenge traditional beliefs with what you think is possible with your role and recognize the opportunity you have in becoming a catalyst for change – regardless of how complex or “broken” your organization has become.

Hopefully, the 3 resolutions for 2016 will be enough to get you started on your journey but there will be much more to come from Illustrated Agile throughout the year.

Look harder. Your team, leaders, and organization is revealing important details about what is needed from the role of Scrum Master (and it may not be a fancy framework or a few Agile buzzwords, tools and ceremonies). Observing takes real practice and journaling is an important way to help improve this trait. Check out the note below to see how you can get a worksheet I have used to help Scrum Masters begin to capture their observations about what they are see and sensing. My most commonly used question when coaching a Scrum Master is “What are you sensing?”

Find more time to think. Take what you are observing and carve out quality time to think…just think. Ask yourself challenging questions. Why is this happening? Why is it really happening? What are all my senses telling me about the situation? What is the system telling me?

Last year we resolved to slow down and allow imperfections to emerge. This year, resolve to create time and space to add a dose of critical thinking to your role.

Hopefully, this quote from Leandro Herrero will inspire you (as it did me):

Critical thinking has wonderful unintended consequences: being humble is one. Free from the heavy load and duty of being always right, a burden that the uncritical thinker tends to bear, the critical one is agile and nimble.

Increase bravery. You’ve sensed what the system is telling you. You’ve given yourself the space to pause and think. Now it’s time to strengthen your resolve to become a catalyst for change. Be vocal. Be a friend. Be a spark. Be a raging fire. Be encouraging. Be strong. Be open to new possibilities. Everyday, ask how you can instigate change in your company culture…otherwise, the culture is slowly changing you.

Have an awesome 2016 everyone! Be brave. Len

For a limited time, get a digital copy of the book “Becoming a Catalyst: Scrum Master Edition” for free when you subscribe to the blog. You will also receive the Becoming a Catalyst Companion Worksheet to help develop the 8 traits of a Catalyst Scrum Master explained in the book.

Becoming a Catalyst - Scrum Master Edition

The post Scrum Master Resolutions (2016 Edition) appeared first on Illustrated Agile.

Categories: Blogs

R: Error in approxfun(x.values.1, y.values.1, method = “constant”, f = 1, : zero non-NA points

Mark Needham - Sun, 12/27/2015 - 14:24

I’ve been following Michy Alice’s logistic regression tutorial to create an attendance model for London dev meetups and ran into an interesting problem while doing so.

Our dataset has a class imbalance i.e. most people RSVP ‘no’ to events which can lead to misleading accuracy score where predicting ‘no’ every time would lead to supposed high accuracy.

Source: local data frame [2 x 2]
 
  attended     n
     (dbl) (int)
1        0  1541
2        1    53

I sampled the data using caret‘s upSample function to avoid this:

attended = as.factor((df %>% dplyr::select(attended))$attended)
upSampledDf = upSample(df %>% dplyr::select(-attended), attended)
upSampledDf$attended = as.numeric(as.character(upSampledDf$Class))

I then trained a logistic regression model but when I tried to plot the area under the curve I ran into trouble:

p <- predict(model, newdata=test, type="response")
pr <- prediction(p, test$attended)
prf <- performance(pr, measure = "tpr", x.measure = "fpr")
 
Error in approxfun(x.values.1, y.values.1, method = "constant", f = 1,  : 
  zero non-NA points

I don’t have any NA values in my data frame so this message was a bit confusing to start with. As usual Stack Overflow came to the rescue with the suggestion that I was probably missing positive/negative values for the independent variable i.e. ‘approved’.

A quick count on the test data frame using dplyr confirmed my mistake:

> test %>% count(attended)
Source: local data frame [1 x 2]
 
  attended     n
     (dbl) (int)
1        1   582

I’ll have to randomly sort the data frame and then reassign my training and test data frames to work around it.

Categories: Blogs

Interpreting Scala in the Browser

Xebia Blog - Thu, 12/24/2015 - 16:38


At this years' Scala Exchange keynote, Jessica Kerr got a nice round of applause when she asked us all to, please, include our import statements when sharing code snippets.

That's great advice - but can't we do better? What if we could share actual running, hackable code?

Turns out we can: there's a number of 'JSFiddle'-style projects around, and I'll take a brief look at some of them.

Scala-Js-FiddleSelection_045

Scala-Js-Fiddle leverages Scala.js: once compiled on the server, your Scala application runs in the browser.

This allows you to create beautiful visuals while running your applications. This could be an awesome teaching tool.  Be sure to check out their documentation, which comes generated on-the-fly by a Scala snippet!

The downside of using Scala.js is of course that you're restricted in which libraries you can include.

ScripsterSelection_046

Scripster by Razvan Cojocaru (github) allows you to write Scala code in a syntax-highlighted environment, and gives some control over which expressions are evaluated.

Even though this tool is not restricted to Scala.js, only a limited number of libraries is included.

Scala KataSelection_047

Scala Kata by Guillaume Massé (github) is an attractive editor with completion features, which feels much smoother than Scripster.

While again you don't have control over which dependencies are available, a nice collection is included.

Unlike other options Scala Kata does not show the output of the program, but the value of the expression on each line, which might be familiar if you've ever worked with the 'notebook' feature of Scala IDE. While sometimes constraining, this encourages a nicely functional style.

Scala Kata is currently my online Scala environment of choice, though unfortunately it doesn't provide an easy way to store and share your snippets.

Scala NotebookSelection_048

Scala Notebook looks pretty clean, but unfortunately does not appear to be available in hosted form anywhere.

The project takes its inspiration from the IPython notebook, which is indeed a great example.

An interesting aspect of Scala Notebook is that, somewhat like scala-js-fiddle, it allows rich output: when a command returns HTML or an image, it will be rendered/shown.

scastieSelection_049

Users of scastie will have to do without fancy features such as advanced highlighting and completion, but gives you complete control over the sbt configuration - making it a very powerful alternative.

 

Round-up Overview intermediate values completion git(hub) dependencies scala version Scala-Js-Fiddle no no yes no n/a Scripster no no no limited 2.9.1 Scala Kata yes yes no limited 2.11.7 Scala Notebook yes no no full control scastie no no no full control configurable The future

Some desirable features, like a more 'direct' REPL-like interface, are not widely supported. Also, none of the available offerings appear to be particularly easy to embed into an existing site or blog.

If these services would become wildly popular, I wonder whether making sure there is sufficient back-end computing power available might become a challenge. On the other hand, computing is rapidly becoming cheaper, so this might not be an issue after all.

Concluding

I was amazed by the number of projects that managed to make a functional Scala programming environment available in the browser. While there's more work to be done, there is amazing potential here.

Categories: Companies

20 PMI-ACP v2 Sample Questions

Leading Answers - Mike Griffiths - Thu, 12/24/2015 - 03:53
Following the update to the PMI-ACP Exam with the addition of the new “Agile Principles and Mindeset” domain I updated my PMI-ACP Exam Prep book and have now just finished the new questions for FASTrack Exam simulator. Feedback from people... Mike Griffiths
Categories: Blogs

SAFe in Government: Major Contract Awarded to SAI Gold Partner for SAFe Implementation

Agile Product Owner - Thu, 12/24/2015 - 00:25

safe_in_governmentThe Administrative Office of the U.S. Federal Courts awarded Scaled Agile Gold Partner SRA International a five-year contract valued at $115 million. SRA will provide full software development lifecycle expertise for a variety of applications supporting probation and pre-trial services, as well as Case Management/Electronic Case Files which is the system that manages the electronic court filings.

It is gratifying to see the progress that Agile and SAFe are making in the government space (see last post). After all, these are our tax dollars being spent. And as Lean thinking drives elimination of waste, the government is a target-rich environment, as they say on the beltway.

You can read the full press release here, but for anyone monitoring the progress of SAFe in the government, this is the interesting part:

“As part of the program, CSRA will continue to support the CMSO as it transitions all application development to Agile methodologies leading to the implementation of the Scaled Agile Framework® (SAFe®) and Development/Operations (DevOps) methodologies.”

Note: SRA is a subdivision of CSRA.

Happy Holidays everyone!
—Dean and the SAI team

 

 

Categories: Blogs

SAFe in Government: Major Contract Awarded to SAI Gold Partner for SAFe Implementation

Agile Product Owner - Wed, 12/23/2015 - 18:40

safe_in_governmentThe Administrative Office of the U.S. Federal Courts awarded Scaled Agile Gold Partner SRA International a five-year contract valued at $115 million. SRA will provide full software development lifecycle expertise for a variety of applications supporting probation and pre-trial services, as well as Case Management/Electronic Case Files which is the system that manages the electronic court filings.

It is gratifying to see the progress that Agile and SAFe are making in the government space (see last post). After all, these are our tax dollars being spent. And as Lean thinking drives elimination of waste, the government is a target-rich environment, as they say on the beltway.

You can read the full press release here, but for anyone monitoring the progress of SAFe in the government, this is the interesting part:

“As part of the program, CSRA will continue to support the CMSO as it transitions all application development to Agile methodologies leading to the implementation of the Scaled Agile Framework® (SAFe®) and Development/Operations (DevOps) methodologies.”

Note: SRA is a subdivision of CSRA.

Happy Holidays everyone!
—Dean and the SAI team

 

 

Categories: Blogs

Stop Doing Scrum and Start Being Agile

TV Agile - Wed, 12/23/2015 - 18:00
Learn you should stop trying to implement a methodology from a book in just one team and instead try to create an Agile methodology for your company as a whole. This video discusses the history of Agile and the ideas behind it. You will learn how you can enlighten your company about the advantages of […]
Categories: Blogs

Targetprocess v.3.8.0: People Allocations Management, Custom Fields for Team

TargetProcess - Edge of Chaos Blog - Wed, 12/23/2015 - 17:05
People Allocations Management

The people allocation management feature provides the possibility to plan people allocations on projects, taking into account their current and planned allocations to see if any conflicts might happen. It allows the user to specify what people – teams and individuals – are required for a project, how long they will be needed and what % of their total working hours they can be available.  By using this information you are able to visualize and manage possible over-or under allocations for individuals or teams. Read more about it here.

PPL

Please note that all the Project Allocations will be converted to User Allocations with version 3.8.0 and the views, which contain Project Allocations entities as cards, should be replaced with new views containing user allocations and team allocations as cards. More details about data migration is available here.

Custom Fields for Teams

Before this release all custom fields were part of some specific Process. Since a Team does not depend on a particular process, it wasn’t possible to create custom fields for them.  Starting with v.3.8.0 we’ve added the possibility to create custom fields for Teams with no reference to Process!
Administrators can add them by going to the Settings Gear > Settings > Custom Fields.  This is a new page that shows all the custom fields, across all processes, that have been created in your Targetprocess instance. You can sort and filter this list by Entity Type, Field Type or Process.  Then use the fields on your views.   As an example, a location for teams:

team-location

 

Fixed Bugs and Minor Features
  • Performance Improvements: Lite context and partial comet updates
  • Add a warning on report update from the Designer tab added if it was set up with DSL
  • Progress of a completed entity remains 0%
  • Related entity (UserStory) is skipped when filtering (by UserStory.Tags) and the field of the entity (Tags) is used instead
  • TFS Plugin: Fixed out of memory exception
  • Link for password reset won’t be sent if a deleted user with the same e-mail exists in database
  • Custom business rule ‘Assign a Task to the Person who started it’ works only for the state that goes right after Initial or Planned
  • Non-admins can change their project roles without permission to roles that has ‘add/edit project’ option ON
  • List view fails if it’s configured to show different card types and only of them has been customized with a TP Entity Custom Field unit
  • Aggregations “InboundAssignables.Max(TeamIteration.StartDate)”, “InboundAssignables.Max(StartDate)” should work correctly now
  • Bugzilla v.5.0 integration supported
Categories: Companies

Scrum & Agile Project Management Antipatterns

Scrum Expert - Wed, 12/23/2015 - 16:29
Agile is a now mainstream method used in IT project management. Yes, Agile and Scrum are now considered as a method and no longer as a philosophy. Everyone wants to “do” Agile and thus want to “be” Agile as well, but what are the common mistakes in applying Agile? This video covers the following topics: * The bitter truth about IT projects * Complex project nightmares * Are we ...
Categories: Communities

Aanbevolen boeken over agile

Ben Linders - Wed, 12/23/2015 - 13:18

Banner Aanbevolen boeken Ben Linders textBen je op zoek naar een goed praktische boek over agile software ontwikkeling met b.v. Scrum, Kanban of Lean? Of naar een bruikbaar boek over leiderschap of verandermanagement? Op benlinders.com/boeken vindt je mijn boek aanbevelingen.

Alhoewel steeds meer informatie beschikbaar is op websites, in blogs en in communities en discussiepagina’s, spelen boeken nog steeds een belangrijke rol. In boeken wordt vaak dieper ingegaan op de materie, wat belangrijk is als je het toe … Continue reading →

Categories: Blogs

Uncovering the mysteries of Swift property observers

Xebia Blog - Wed, 12/23/2015 - 12:31

One of the cool features of Swift are property observers, perhaps better known as the willSet and didSet. Everyone programming in Swift must have used them. Some people more than others. And some people might use them a little bit too much, changing many of them together (me sometimes included). But it’s not always completely obvious when they are called. Especially when dealing with struct, because structs can be a bit odd. Let’s dive into some situations and see what happens.

Assignment

The most obvious situation in which didSet (and willSet) gets called is by simply assigning a variable. Imagine the following struct:

struct Person {
    var name: String
    var age: Int
}

And some other code, like a view controller that is using it in a variable with a property observer.

class MyViewController: UIViewController {
    var person: Person! {
        didSet {
            print(&quot;Person got set to '(person.name)' with age (person.age)&quot;)
        }
    }

    override func viewDidLoad() {
        person = Person(name: &quot;Bob&quot;, age: 20)
    }
}

As you would expect, the code in didSet will be executed when the view did load and the following is printed to the console:

Person got set to 'Bob' with age 20
Initialization

This one is also pretty clear and you probably already know about it: property observers are not executed then the variable is assigned during initialization.

var person = Person (name: "Bob", age: 20) {
        didSet {
            print("Person got set to '(person.name)' with age (person.age)")
        }
    }

This doesn’t print anything to the console. Also if you would assign person in the init function instead the willSet will not get called.

Modifying structs

A thing less known is that property observers are also executed when you change the member values of structs without (re)assigning the entire struct. The following sample illustrates this.

class ViewController: UIViewController {

    var person = Person (name: "Bob", age: 20) {
        didSet {
            print("Person got set to '(person.name)' with age (person.age)")
        }
    }

    override func viewDidLoad() {
        person.name = "Mike"
        person.age = 30
    }

}

In this sample we never reassign the person in our viewDidLoad function but by changing the name and age, the willSet still gets executed twice and we get as output:

Person got set to 'Mike' with age 20
Person got set to 'Mike' with age 30
Mutating functions

The same that applies to changing values of a struct also applies to mutating struct functions. Calling such a function always results in the property observers being called once. It does not matter if you replace the entire struct (by assigning self), change multiple member values or don’t change anything at all.

struct Person {
    var name: String
    var age: Int

    mutating func incrementAge() {
        if age < 100 {
            age++
        }
    }
}

Here we added a mutating function that increments the age as long as the age is lower than 100.

class ViewController: UIViewController {

    var person = Person (name: "Bob", age: 98) {
        didSet {
            print("Person got set to '(person.name)' with age (person.age)")
        }
    }

    override func viewDidLoad() {
        person.incrementAge()
        person.incrementAge()
        person.incrementAge()
        person.incrementAge()
    }

}

Our willSet is called 4 times, even though the last two times nothing has changed.

Person got set to 'Bob' with age 99
Person got set to 'Bob' with age 100
Person got set to 'Bob' with age 100
Person got set to 'Bob' with age 100
Changes inside property observers

It is also possible to make changes to the variable inside its own property observers. You can reassign the entire variable, change its values or call mutating functions on it. When you do that from inside a property observer, the property observers do not trigger since that would most likely cause an endless loop. Keep in mind that changing something in willSet will be without effect since your change will be overwritten by that value that was being set originally (this gives a nice warning in Xcode as well).

class ViewController: UIViewController {

    var person = Person (name: "Bob", age: 98) {
        didSet {
            print("Person got set to '(person.name)' with age (person.age)")
            if person.name != oldValue.name {
                person.age = 0
                print("Person '(person.name)' age has been set to 0")
            }
        }
    }

    override func viewDidLoad() {
        person.name = "Mike"
    }

}
Why it matters

So why does all this matter so much you might think. Well, you might have to rethink what kind of logic you put into your property observers and which you put outside. And all this applies to Arrays and Dictionaries as well, because they are also structs. Let’s say you have an array of numbers that can change and each time it changes you want to update your UI. But you also want to sort the numbers. The following code might look fine to you at first:

class ViewController: UIViewController {

    var numbers: [Int] = [] {
        didSet {
            updateUI()
        }
    }

    override func viewDidLoad() {
        refreshNumbers()
    }

    func refreshNumbers() {
        numbers = [random() % 10, random() % 10, random() % 10, random() % 10]
        numbers.sortInPlace()
    }

    func updateUI() {
        print("UI: (numbers)")
    }

}

Every time numbers changes, the UI will be updated. But since sortInPlace will also trigger the property observer, the UI gets updated twice:

UI: [3, 6, 7, 5]
UI: [3, 5, 6, 7]

So we should really put sortInPlace inside willSet right before we call updateUI.

Categories: Companies

Taking Requests for New Edition of Manage Your Project Portfolio

Johanna Rothman - Tue, 12/22/2015 - 17:37

Manage Your Project PortfolioI am about to update Manage Your Project Portfolio: Increase Your Capacity and Finish More Projects to a second edition.

What would you like me to add? To remove? To change? What have your challenges been about project portfolio management?

Here are things I’m planning to add:

  • Many more kanban views of the project portfolio and some words about visualization.
  • Discussion (or more than one) about Cost of Delay.
  • How a project’s product backlog is not the same as an organization’s project portfolio.
  • More discussion about what you optimize and why.

What else would you like to see? Please either comment or send me email. Thanks!

Categories: Blogs

Faster Time to Market: An Interview with Cerner

Agile Management Blog - VersionOne - Tue, 12/22/2015 - 15:30

At Agile 2015, we had the opportunity to interview Matt Anderson, director, Cerner Technology Services, to find out how their organization is using VersionOne to accelerate speed to market and increase throughput to stay competitive in a rapidly changing industry.

In the video below, Matt talks about the organization’s partnership with VersionOne has helped them align its people, processes and technology to realize significant results from agile over the past seven years.

Highlights

  • Time to market reduced by 75%
  • Productivity increased by 24%
  • Development costs reduced by 14%
  • Turnaround time for resolving critical defects reduced by 50%

Challenges

In 2009, it was typically taking Cerner’s development teams about 30 months – from concept to client adoption – to introduce major innovations. Cerner knew it had to accelerate its products’ time to market to help clients navigate health care reform and to stay competitive in the rapidly changing industry.

To achieve this, Cerner’s developers needed more agility in their software development processes. The solution was the adoption of agile practices across the enterprise. Matt Anderson, director, Cerner Technology Services and Cerner’s leading agile champion, calls the company’s approach “pragmatic agile.” In other words, the enterprise focuses on ensuring that agile principles and values are followed and the teams decide the agile approach they will take.

Successful organizational change must simultaneously incorporate people, process and tools. While Cerner had a great team who was committed to agile processes, they needed an enterprise agile application lifecycle management (agile ALM) platform that would enable the people and processes to succeed. After reviewing several options, they selected VersionOne as their primary tooling partner.

Solution

Cerner has more than 3,000 developers, with teams having different needs, different markets, and different preferences in the way they work. Scrum works best for most of their teams, while other teams prefer Kanban, XP, Lean or other variations.

The company selected the VersionOne agile ALM platform because it had the flexibility to accommodate the various agile methodologies being implemented. In addition, they found the platform intuitive and easy to use. “People can focus on doing the real work of software development,” explains Anderson.

Benefits

For Cerner, success was about having more time to focus on adopting the agile framework rather than adopting a tool. The VersionOne platform’s inherent ease of adoption enabled Cerner to quickly start seeing the benefits of agile – in this case, a 75% reduction in time to market. Other measurable improvements include:

  • Productivity increased by 24%
  • Development costs reduced by 14%
  • Quality improved by 6% based on internal KPIs
  • Turnaround time for resolving critical defects reduced by 50%

In addition, by choosing VersionOne, Cerner development teams can estimate software delivery more accurately, allowing them to forecast and consistently meet their commitments to stakeholders. Developers can identify problems earlier and make midstream adjustments very quickly. And teams can innovate and test prototypes because VersionOne is adaptable enough to support changes to the underlying process.

The flexibility of the VersionOne ALM platform promotes a proactive approach to problem solving across the enterprise. Instead of reacting to issues, Cerner can develop solutions that prevent issues from arising. The flexibility also allows teams to try different things. If the experiment works, Cerner teams incorporate it as a part of their process. If the experiment doesn’t work, they just throw it out and try something else. As Anderson says, “That’s the true spirit of retrospectives.”

Another key benefit of VersionOne is the ease of creating roll-up reports with the ability to drill down from big picture into what teams are doing. With VersionOne, Cerner’s leadership can get a one click view of a release at any point in time. They no longer needed to deal with project management via spreadsheets or Visio, which often contained outdated information and rarely provided the needed level of detail.

“VersionOne is a great partner,” said Anderson. “The company continues to innovate to meet the needs of the agile marketplace. They are justifiably one of the top agile ALM vendors.”

Please visit VersionOne’s YouTube page for more video interviews.

The post Faster Time to Market: An Interview with Cerner appeared first on The Agile Management Blog.

Categories: Companies

Handling impediments: Understanding Problems

Ben Linders - Tue, 12/22/2015 - 14:20
In this third post in the series on handling impediments I'll explore what you can do to understand the impediment and underlying the problems that the team is trying to deal with. Previous posts explained why impediments matter and how you can recognize the problem. Continue reading →
Categories: Blogs