roundcrisis

Bytesize Architecture Sessions for DDD Discovery

Tue, 03 Mar 2026 00:12:00 +0000

The DDD Starter Modelling Process is an excellent guide when iterating through the design process. This process is recommended when planning or following significant change, or when there are changes in terms of personnel. Some good examples: major programme of work, beginning brownfield migration, re-organising teams, etc.

I have been using Bytesize Architecture Sessions in a few of the sections of the Domain-Driven Design modelling process. This article focuses on the Discovery section of the starter process.

DDD Starter Modelling Process by DDD-Crew

Discovery is about sharing domain knowledge. When domain knowledge is shared widely, the team builds a collective understanding that leads to software aligned with the domain. This enables both the team and the software to evolve with the business. Discovery is an enabling step that opens the door for more team members to bring forward innovation for the product.

The Discovery Step

In my experience, starting Discovery with EventStorming is a great way to understand the system in terms of what domain experts truly care about, how the system behaves through time, and so much more.

After EventStorming, it’s useful to understand the current structural shape of your system, as it is right now. Use Bytesize Architecture Sessions with C4 to address this.

Bytesize Architecture Sessions Overview

Bytesize Architecture Sessions are a workshop format that helps groups understand the systems they work on. Each session focuses on a specific section of a system. Over multiple sessions, the group will converge on a better shared understanding, develop a consistent vocabulary, and build a foundation for designing the future together.

Each Bytesize Architecture Session lasts between 45 and 90 minutes and has four well‑defined parts: Session Goal, Alone Together, Convergence, and Introspection. You can model your systems using different tools, such as C4, Context Mapping, or the Bounded Context Canvas. For teams new to modelling I recommend starting with C4.

C4 Overview

C4 is a simple, hierarchical, and easy‑to‑learn modelling tool. It has four key diagrams. They move from high level abstractions of the System Context where you think in terms of systems and people, the forest. Then, one level down are C4 Containers, the trees. Below that are the C4 Components, the branches. And at the most detailed level is the Code Diagram, the leaves. This last diagram is customarily generated automatically.

Bytesize Architecture Sessions for Discovery: A Practical Walkthrough for Smaller Groups

If you work with a cross‑functional team of ten people or fewer, the organisation of Discovery workshops is simpler. You may start with a Big Picture or a Process Model EventStorming workshop, then run a series of Bytesize Architecture Sessions over a few days to produce a System Context diagram and the chosen Container diagrams together.

It’s best to hold the first session in person, as it’s easier to address any issues this way. It will enable better dynamics for questions and gathering feedback. Schedule the subsequent sessions a few days later.

To kick the series off it’s a good idea to explain why the group should be doing this activity and an overview of the format. The goal and the activity should not be a surprise to any of the participants.

Discovery Kick Off

As the Bytesize Architecture Session aspect of Discovery starts, ensure your participants are prepared:

Teach all participants about C4. A short explanation with examples works well
Ensure they have stationary, such as markers and suitably sized paper

Proceed with the workshop:

Goal of the session. State the goal of this session: “Create a System Context Diagram of the system as it currently is”. Check for questions, ensure everyone is able to participate (e.g they can create a diagram individually). Ask attendees to confirm they understand the goal and that everyone attending is expected to create a diagram
Alone Together. Set up a timer for five minutes. All attendees create a diagram. When the timer elapses, everyone listens as each person describes their diagram without interruptions
Convergence. With the context from the previous step, create one System Context diagram that is the convergence of all ideas. This section is the longest, set up a timer for thirty minutes.
Introspection. Five introspective minutes to consider what each participant thought of the session. I generally run this as a fast mini-retro

It’s highly likely that the individual diagrams will look different to each other. A common pattern, especially for those less familiar with C4, is to have different levels of abstraction present in the diagram. A good diagram is a useful outcome only if all attendees understand and learn why the diagram looks the way it does, and what each item in the diagram represents. It’s important to remember that the goal of running Collaborative Modelling¹ sessions like this one, is to grow understanding together.

Participating and co-creating is the outcome, the picture we create is a tool to help the participants retrace their steps.

Next Sessions

Help participants notice the effects of iteration, how they can point at an item in the diagram and understand how it got to its current state. This is why the Introspection step at the end of the Bytesize Architecture Session is so valuable.

The format for each of the following Bytesize Architecture Sessions will be the same as the first one. The goal should change as participants converge on the System Context Diagram, and then, on the selected Container Diagram.

Iterating on the diagrams is to be expected. For example, it’s common for the System Context Diagram to need updates after working on the Container Diagram.

Logistics and Tooling

For the next sessions, either the online or in-person format are fairly similar. Please see the tools section of the Bytesize Architecture Sessions website for more information about options.

Bytesize Architecture Sessions: A Practical Walkthrough for Bigger Systems

Larger systems tend to have more people involved. The most common case is when there are three to five teams working on a system. The teams might represent Engineering for the whole company or, for bigger organisations, they might represent a department.

Before diving into the steps, it helps to clarify how people participate. Due to the number of people involved a neutral facilitator is strongly recommended. The facilitator guides the flow of the session, manages time, and ensures balanced participation. Their role is both about keeping the group moving, and creating the conditions for shared understanding. Participants with leadership responsibilities join as co‑explorers. They should pay special attention to the language use, how mental models differ across participants and teams, and where boundaries or abstractions are unclear. Noticing and making these explicit is where they can add significant value.

Before the Sessions

Engage with the organisation’s leadership to learn about who to invite. There should be at most twenty five participants present. Consider:

Overall team size
Cross‑functional representation. Include Engineering, QA, Design, Product, and Operations (especially teams handling configuration changes or customisation work)

With larger groups, it’s particularly valuable to do this first session in person, alongside other Design kick off activities. For example, run a Big Picture EventStorming on day 1 and run this first session on day 2.

In addition to selecting the right participants, a few practical setup considerations are needed for the session to run smoothly:

For a group this size a dedicated facilitator is needed
For an in person event, a room large enough to comfortably accommodate all participants. The room should have tables seating five people each
Access to a big screen, or alternatively as many large whiteboards as tables, or both!
Duration 90min.

Discovery Kick Off

Once the date is set, the participants confirmed, and a facilitator in place, the following is a representative set of steps:

Logistics. In person, setup tables for up to 5 people per table. Once everyone has arrived, redistribute people so that each table has a mix of roles and team membership
Teach C4. A short overview is best, and the infographic above provides a useful reference. Mention that they are going to try this in the next few minutes
Goal of the session. It’s the same as in the simpler case above: “Create a context diagram of the system as it is right now”. Make sure to mention that when the timer starts, everyone individually will create a diagram, and that when the timer elapses they will have to explain the diagram to the rest of the table.
Alone together. Start the timer. Five minutes is a good default. At this point the room should be silent. When the timer elapses, each member of the table will explain the diagram they created to the rest of the table. Everyone else at the table is expected to listen, withholding questions and comments until everyone is done
Convergence. Set a timer for twenty minutes. On a per table basis they create one diagram together.
- Show and Tell. A candidate from each table presents their diagram to the room. Ideally, the person who knows least about the system. Set another timer for three minutes and task the groups with cleaning up the diagram and preparing the speaker.
- What to expect. It’s usual that the diagrams look different from each other. Often the language is generic, or the words used to describe the different parts of the system don’t match. When the boundaries very unclear, the abstractions between System and Container will be blurry. The key is for the participants to understand and bring the abstractions they know of into focus.
Introspection. Use sticky notes and a timer to run a short retrospective for the group at large. Identify themes and discuss. Maximum ten minutes long.

The steps above described an in person event. To host this session online, an experienced facilitator is essential.

Next Sessions

Some considerations for the next Bytesize Architecture Sessions

Revisit the guest list. Depending on availability and roles they might be more or less suitable. Consider, are the participants able to contribute meaningfully? Does it help them in their role?
Have a strategy to make the outcomes of the sessions accessible to the wider organisation and consider a way to gather feedback
Start each Session with a short review of where you left the last time. A quick overview is a great way to set the scene, then proceed with the goal
If hosting online, have a template ready. Include images from the previous Bytesize Architecture Session
Help participants see the effects of iteration. How they can point at something in the diagram and understand its current state. This is why the Introspection step at the end is so valuable

The format of each of the Bytesize Architecture Session will follow the pattern of the infographic above. The goal should change according to how far people converge on the System Context Diagram and then, to the selected Container Diagram.

It is possible that after working on the Container Diagram, the System Context Diagram needs to be updated. This reinforces the idea that the diagrams evolve with the group’s understanding rather than being fixed outputs.

Outcomes

After a few Sessions the participants have:

Created a model of what they think their system looks like together. If there are unanswered questions or an unfinished diagram, the type of questions surfaced and how the diagram is not complete will make knowledge gaps visible
Shared what they know about their systems
Heard different perspectives and, ideally, incorporated sections into the model they created together
Learned C4 with hands-on experience
A suitable setup to continue iterating into deeper insights.

With time, assuming your organisation or teams adopt the practice, you will see the following effects:

Participants know this is a time and place for advice when making significant changes. This requires support from leadership to sustain the practice
Participants learn that no one knows everything. This tends to improve psychological safety
Designs become more nuanced, as participants get better at modelling
Everyone wants to learn DDD 🕶️ 📖

Common Anti‑Patterns

Staying on one discussion for too long. If participants are staying on a topic and not agreeing, perhaps more context is needed. The impasse can be either addressed offline or in a follow up session focusing on that issue only. At minimum, document the issue precisely, and move on towards the goal
Focusing on creating the perfect diagram, rather than understanding how the system works
Frustration because the diagram is “not finished” and the timer elapsed. Some level of discomfort with this is to be expected, however in this case it’s important to mention that we are constraining on time rather than completion. Indicate that the focus is on learning, understanding, and not the artifact. The models created are reflective of the systems, and those are never finished either
Treating Bytesize Architecture Sessions as a meeting instead of a workshop. This can be a problem if there are people that dominate the conversation. These type of issues might require coaching
Precisely planning a series of Bytesize Architecture Sessions with expected outcomes for each session. The way people collaborate, requires flexibility and meeting participants where they are at. Having a plan is ok as long as the plan can be updated.

Success Metrics

These can be useful metrics depending on your issues:

A couple of weeks after a knowledge sharing session, ask participants to explain why a system or decision is the way it is. Not what it does, but Why
Track when new joiners stop needing extra context or ask for validation on decisions.
Incident response and diagnostic speeds up. How long does it take to identify the root cause, and how many people need to be involved?
Track the key-person risk. Identify top N people with the highest domain knowledge concentration in your organisation. Over time, are those same people still the ones with the highest domain knowledge concentration? Why?

Conclusion

Significant changes generally bring a high level of uncertainty. Bytesize Architecture Sessions help by creating a safe space for design, in a deliberate manner, in short and iterative bursts. Creating shared models help reduce risk and increase clarity. I have shared what works for me. I encourage you to try it and see how it works for you. Perhaps certain aspects of this practice needs to be adapted for your context in some way. I would be very happy to hear about it.

The next post will describe how to use Bytesize Architecture Sessions for Define. Until the next time.

Collaborative modelling is an approach experts, practitioners, and end-users, work together to create, refine, and validate models. Leveraging the diverse perspectives and expertise of the participants to enhance the model’s accuracy, relevance, and usability. By involving a wide range of contributors,it fosters a deeper understanding of complex systems and promotes shared ownership of the outcomes. (Adapted from https://www.michael-ploed.com/collaborative-modeling) ↩

The Making of a Decision - Part 5 - Introducing Decision KP Maps

Wed, 04 Feb 2026 00:12:00 +0000

So much about decision making is about trust. Trust in the information and knowledge you have, trust in what your colleagues say they will do and how likely they are on delivering on their promises. When I was working with a client a few months ago, they had some difficulties progressing

The series covers the topics described in this talk: The Making of a Decision. This is part 5 of the series about decision making in software systems.

The Making of a Decision - Part 1
The Making of a Decision - Part 2 - Knowledge
The Making of a Decision - Part 3 - Tools for groups
The Making of a Decision - Part 4 - Team and Personal Tools
The Making of a Decision - Part 5 - Introducing Decision KP Maps - This post

Part 1 of this series explored how power shapes organisational and architectural decision making by reviewing definitions, laws of power and more. Part 2 covered concepts and models relating to Knowledge, what we mean when we say we know something and who has the right to know things. Part 3 and 4 covered decision making tools for different group sizes. This is a post that introduces Decision KP Map, the tool I created as result of learning and discussing so much about the subject.

What is Decision KP Map?

The process of making a decision involves people that have varying degrees of the capability to make change and people that have varying degrees of knowledge on the matter, sometimes people have both. This type of mapping I’m proposing is something you very likely, already do intuitively. Mapping will help you better understand:

The interactions between the people and the decision
The dynamic aspect of the relationship between people involved and
Developing patterns and what to do about them

Decision KP Map is a mapping tool that helps visualise your subjective perception of the community that enables decision making.The Key People, in terms of their Knowledge and Power. Both concepts are the reason for the name of this tool.

Edit 04th March 2026: Given this definition of stakeholder¹

A stakeholder in the architecture of a system is an individual, team, organization, or classes thereof, having an interest in the realization of the system.

Key People are all stakeholders. Meaning that Decision KP Maps is another way to do stakeholder mapping. Thanks Dianing Yudono for your feedback

Who is this tool for

This tool is especially helpful for people who are part of the decision making process or who are the decision makers themselves. It’s useful for those who value knowledge in a particular context.

People who do software design, architecture, or have team‑leadership responsibilities are likely to find this tool most useful.

A sample Decision KP Map

Below you’ll find an example map where I added people from history, and others described by roles to help create a baseline.

How to read this map

Capability to make change. On the horizontal axis the scale moves from can’t to can make change happen. You might think of it as a proxy for influence, power and the like. Avoid fixing your view on hierarchy alone, because that gives an incomplete picture. Instead, answer Who is actually able to bring about change in the given context? Begin by recognising the individuals who can make change, then examine the factors that enable them.
Valid and/or accepted knowledge and information.The vertical axis denotes a spectrum from doesn’t have to has accepted, valid knowledge. While debating decisions, note the individuals with thorough understanding and note how they have actively enriched the knowledge pool. A common pitfall is to always credit the most senior person; instead, recognise the genuine source of the information.
People position. Where you position people depends on your subjective understanding. What is important is that the whole map is self consistent. A good way to do this is place all the people and then check that all the people are placed somewhere that makes sense when comparing it with others in the map, for example you might think: JP knows as much as QW about this subject, AR is nearly as able to make change as RB but just not as much.

I have added historical figures to the map, together with a few roles to illustrate the map’s range:

Katherine Johnson @ Crewed NASA space flights team. My knowledge on her role is based on reading online about her work after seeing the film Hidden Figures. We can understand that she was uniquely capable as well as extremely limited in capability to make change due to social and cultural constraints. If I had to add her to a map she will be in the top left quadrant.
Don Syme @ F# Programming Language Project. Don has the most knowledge about the F# programming language project as well as complete control over the direction of the language… as far as I know. If we were drawing a map about who we should probably involve when it comes to changes to the F# programming language, it would be a good idea to:
1. Attempt to validate that Don has the authority assumed and,
2. If incorrect, Don would still have a lot of knowledge and influence on the project. You definitely would want to ask his advice when it comes to decision making in this space. In a case like this, you might add him in some maps and omit on others.
Intern. An intern is someone that is trying to learn the profession. Even if a particular intern is extremely capable, it would be irresponsible to not supervise their work and take either their knowledge or capability to make change for granted.
Propaganda writer. Please remember this is an example, very few people within companies act this way on purpose. If you ever had to interact with someone that is writing a piece that is either disinformation (deliberately hiding the truth) or misinformation (incorrect but not clear if deliberate) the result has similar outcomes. It’s harder to make decisions when people like this are in the mix. They might have sufficient capability to make change and push outcomes towards their agenda, based on information you know or suspect to be incorrect.

How does it work? A simple example

To understand how to create and read a map, please see the following map and description

Upper Portion The map shows 🟨Danna P, an Engineer, who has a great deal of knowledge about the decision. This knowledge is accepted and, as far as you know, correct. They also have some ability to make change happen. Although 🟪Bo L outranks 🟨Danna P, 🟨Danna P has slightly more capability to influence change in the context of this decision.

Also in this part of the map is 🟪Bo L,a Principal Engineer, who has slightly less knowledge and slightly less capability to make change on this decision.
Left Side Moving down the vertical axis, we see 🟦Keiko J, an Intern who knows roughly half as much as 🟪Bo L about the subject of the decision and has very little leverage.
Middle Right At a similar level of accepted knowledge, we have ⬛Miles P, who has some capability to make change in this context. We also have 🟩Geordi Z, an Engineering Manager, who has a great deal of capability to make change happen but does not have much context or knowledge about the decision.
Lower Middle Right Finally, we have 🟧Ro H, an Engineering Manager with about the same level of capability to make change as ⬛Miles P. However, their knowledge is incorrect and outdated, and they did not show curiosity about validating it during this interaction.

Note: The shape of this map is a common pattern that often appears during unexpected technical incidents, where decisions require coordination between those who understand the problem and those who are positioned to make decisions about it.

Continuing with the example, a few days have elapsed and things have changed. How? The map below depicts a meeting where things have changed slightly since last time.

What happened:

🟪Bo L asked ⬛Miles P, someone 🟩Geordi Z respects at a technical level, to have a chat with 🟩Geordi Z about this decision. This had the effect of levelling up 🟩Geordi Z’s knowledge as well as increasing ⬛Miles P’s capability to make change, due to the influence increase on 🟩Geordi Z.
It improved BL’s capability to make change slightly as GL brokered the conversation between ⬛Miles P and 🟩Geordi Z

Strengths

Highlight misalignments. It’s a tool to prompt reflection, help you guide stakeholder engagement and discussion, and improve collaboration in decision making. It also helps you question your ladder of inference.
Dynamic Tracking. Repeated use helps with capturing the dynamic interactions of the decision, which is essential in decision processes.
Clear and easy to learn. The core idea is straightforward, and does not require deep technical skills or complex software.
Discover patterns. Over time, it can help discover some basic patterns and biases of individuals across decisions. For example, you might notice that when certain people enter the room, knowledge-sharing stops, or specific topics become off-limits. These might be essential to the making of this decision. I will be following up on the patterns that keep repapering in a another post soon.
Scale up your leadership team. Mapping can help those new to leadership to navigate decision making, perhaps initially with some coaching. Many people who write code (roles and titles vary) enter decision making with a significant level of technical knowledge but limited understanding of how the rest of the decision making process works. This tool can help them.

Limitations

Ideal for decisions with less than 15 stakeholders. it becomes too hard to track everyone otherwise
Mapping takes time. Those who would benefit from this tool the most tend to be in back to back meetings
Lack of digital support. Experienced mappers might not feel this pain so much, but for those new to tools like this it can be overwhelming.

How to start mapping? Paper or Online

Offline. Paper is a low friction solution and preferred by many, harder to share.
- For names, use initials or some code name and a reference page that you can easily move around. Sticky notes with bluetack has worked well for me
- If you are adding anything that is not a person to the map, such as arrows or extra context, add it in a different colour.
Online:
- Any online board (Miro, tldraw, FigJam, etc) will support this
- A board per decision - Name board with the problem statement until a decision has been made. When a decision is made, rename the board to reflect the decision.
- I use a colour per person if the group is small. if two people represent a group I use the same colour
- I tend to copy the last map and move whatever is needed in the new map

Some people have requested digital support for this tool. It might be worth building, though to do that I would love to know that some of you would use it. Please try mapping with existing tools first and let me know what’s missing.

Other uses

Retrospectives or Project kick-off sessions. I can imagine some scenarios where this might work extremely well, I can also imagine this being a disaster. This is why I advocate this as a solo tool
Teaching people who are levelling up. This was mentioned by most of the people trying this tool
Share with others what you think it’s happening

More to do

These are some areas I haven’t had the chance to investigate yet:

Scaling the practice. Decision KP Maps are ideal for decisions that involve ~20 people. It becomes harder to map when mapping more people in cross-functional groups
Pair subjective view with data driven metrics. To investigate, this is a subjective tool. How could it be used along other feedback and data-driven mechanisms? If you are a manager and keen to try this tool, I would like to talk to you. Please reach out.
Structured guidance on interpretation of the maps. Decision KP Map users map similar things in different ways, however there are emerging patterns and there is a lot to learn by collecting and sharing them. Some examples that have already surfaced (I’m starting to think of it as the “pattern zoo”):
- “CxO or HiPPO🦛 bomb”. What should you look for in your map to detect this situation? Are you the HiPPO?
- The elephant 🐘 into the room. What does a map look like when someone brings a topic everyone knows to be problematic but it’s not possible to discuss?
How to use it in sense making scenarios? I believe it could be useful in some particular settings, for example in kick-off workshops. However this is something that needs to be tested.

If you are curious about any of these and would like to try the tool either with or without my guidance, please reach out I would be very happy to hear about it.

Conclusion

Through this series we dived into rich concepts, practical examples and tools or models to improve the process of making a decision. In this article I have introduced you to Decision KP Maps. What is it, illustrative examples, strengths and limitation of the mapping technique as well as the work planned to grow the tool. I have been collecting feedback on the tool usage over the last six months and plan to share of the insights from the pioneers using this tool

See source https://www.viewpoints-and-perspectives.info/home/stakeholders/ ↩

The Making of a Decision - Part 4 - Team and Personal Tools

Thu, 22 Jan 2026 00:12:00 +0000

The series covers the topics described in this talk: The Making of a Decision. about decision making in software systems.

The Making of a Decision - Part 1
The Making of a Decision - Part 2 - Knowledge
The Making of a Decision - Part 3 - Tools for groups
The Making of a Decision - Part 4 - Team and Personal Tools - This post
The Making of a Decision - Part 5 - Introducing Decision KP Maps

In this post, we will leverage what we learned and turn to tools that help to use these concepts in practice. The following is not a comprehensive list. These are tools I’m familiar with that helped me solve issues in the past. Each tool’s ‘Why use this tool’ section explains how it tackles specific decision-making problems at a high level. For more nuance or extra details please see the resources I linked to or send me some comments or questions.

I decided to group these tools by the size of the group that it affects, as the decision to adopt them is with different roles. For each tool, I will include an overview, provide links to learn more and explain how the tool relates to the topics discussed.

Within a team

Bytesize Architecture Sessions

Overview

Bytesize Architecture Sessions are a workshop format that helps teams understand the systems they work on. Each session focuses on a small slice of a system. After a few sessions, your team will be understand their software systems more consistently, grow a common vocabulary and ultimately build tools to design the future together.

Bytesize Architecture sessions are used in decision-making to facilitate collaborative software design through a structured workshop format that prioritises shared understanding. This approach focuses on cross-functional small groups of eight to ten people engaging in iterative one-hour modelling sessions.

It can be used in the Discovery phase of decision making for understanding the current state and in the Design phase to support option generation or to investigate each option as a group.

Learn more:

📹 A Talk: Knowledge Sharing is Systems Building - Andrea Magnorsky
🗒️ Reference Site: Bytesize Architecture Sessions
🏛️ OPL reference Open Practice Library: Bytesize Architecture Sessions
📔Case Study : Using Bytesize Sessions to Improve Documentation Practices by Jean de Barochez at Payfit

Why use this tool, in the context of better decision making

Easy to learn and introduce: Easy to try, can be a key unlock. Not a big time investment for knowledge sharing.
Improve Understanding: The sessions help groups improve their understanding of complex systems. Each participant “tells the story” of what they modelled, allowing the rest of the group to see exactly how their colleagues perceive the system
Improving Knowledge Flow: Since documentation alone is often insufficient to carry important design ideas, these sessions bridge the gap through continuous, close connection between team members. By coming together after individual work, the team benefits from the highest level of insight and combined experience of the group
Resetting Power Dynamics: “Alone Together” is a key aspect here. By having participants model solutions individually before sharing, the process ensures that no single person’s voice influences or dominates the initial creative phase.

Decision Records

Overview

The idea behind ADRs is to record significant architectural decisions in a format that is both concise and based on an accepted template. Recording decisions helps with making better decisions. As a side effect, there is a quick reference to understand what has been done in the past and why. ADRs provide a modular way to capture the rationale, context, and consequences of architecturally significant choices. Specifically designed to address the shortcomings of traditional, large-scale documentation in agile environments. ADRs should document the specific forces at play. Including technological, political, social, and project specific factors that influenced a decision.

Learn more:

🗒️ A post: Master architecture decision records (ADRs): Best practices for effective decision-making

Why use this tool, in the context of better decision making

Consistent Format. While code and documentation are often insufficient carriers of complex design ideas, ADRs function as a conversation with a future team member. This aspect of the documentation can be modular and version controlled.
Record the context of decisions. Even if you cannot follow the full Architecture Advice Process approach, you can begin by recording your decisions. See this great story The Reality of Systems Change: Facilitating Architecture with Transparency

Personal

Left Hand Column

The Left-Hand Column is a reflective tool developed by Dr Chris Argyris designed to help individuals understand the hidden assumptions and internal dialogues that occur during communication. It is useful for handling difficult conversations, managing awkward meetings, and processing power-related stress. The tool derives from the work on the ladder of inference where, given some data, you quickly form views about a person’s predispositions and eventually act accordingly (see video below for further explanation).

To use this technique, you typically document a conversation by splitting a page into columns:

The Right-Hand Column: What was said and the facts
The Left-Hand Column: Your record what you were really thinking and feeling but did not express at the time

The ultimate objective is to become conscious of the dichotomy between words and thoughts. And to challenge your assumptions about why you are interpreting events in a particular way.

In my practice, I use the left-hand column to note what I think, what I think others might be thinking or note that they are not acting as I expected.

Learn more:

🗒️ Blog post: Tools for High Stakes Communication: Tool #2, Left Hand Column/Right Hand Column by Alex Johnston
📹 Ladder of inference: Ladder of Inference

Why use this tool, in the context of better decision making

Understand power dynamics, starting with self awareness. This tool allows you to pause and inspect your reactions and those of others.
Improving Knowledge Flow: Decisions require asking the right questions and understanding the problem from multiple perspectives. By inspecting your internal dialogue, you can identify where communication is breaking down and maybe people are making incorrect assumptions.

Influence Mapping

Overview

Influence Mapping is a visual tool used to navigate the decision environment surrounding a central decision-maker, or “the D”. It addresses the “Sir Galahad Fallacy”, the mistaken belief that technical facts and “better arguments” alone are sufficient to persuade others. Since architectural choices are often a record of hidden power structures, this tool helps externalise complex socio-technical forces.

Key steps:

Listing and casting: Identifying the authority figure (“D”) and categorising stakeholders.
Rating metrics: Plotting individuals on a matrix based on their level of support and their organisational influence.
Visualising relationships: Drawing arrows to show influence paths, where line thickness represents “permission”, the level of receptivity one person has toward another’s influence.

Ultimately, influence mapping helps with understanding that decision-making is about the community around the decision, even if there is one person taking the full responsibility for it. It can help to evolve the broader decision landscape and leverage existing dynamics, ensuring that technical proposals are taken seriously within the organisation’s social context.

Learn more

🗒️ Blog post series: Influence Mapping (Part 1) By Charles Lambdin- An in-depth series about what is influence and much more. 100% recommended.

Why use this tool, in the context of better decision making

Map power flows. A tool that helps with mapping how one subjectively understand power flows.
Community around decision. Helps you navigate and understand better the group or community around the decision. You will need to speak with people, now you know who to approach, why and have better questions to ask.

Decision KP Map

Decision KP Map is a mapping tool that helps visualise the subjective perception of the community of decision makers, the Key People, in terms of their Knowledge and Power.

It’s a map where you can place your subjective understanding of where people sit in terms of:

How much accepted knowledge they can access and,
How much change they are able to effect.

A Decision KP Map always has a specific context, for example an architectural decision. Over the course of a decision, one would generate multiple maps. People can be added or removed as needed.

Learn more:

🗒️ Blog post: [Introducing Decision KP Map] - The post covers what it is, how it works, and most importantly, how can it help you.

Why use this tool, in the context of better decision making

Understand and highlight misalignments. An easy to learn tool that helps evaluate your misalignments and question your ladder of inference.
Dynamic Tracking: Repeated use helps with capturing the dynamic interactions of the decision, which is essential in real-world decision processes.
Teach people new to leadership how to navigate decisions. Many people who write code (roles and titles vary) enter decision‑making with a significant level of technical knowledge but limited understanding of how the rest of the decision‑making process works. This tool can help them.

Conclusion

The purpose of this series has been to dive deeper into the aspects that go into making a decision that are not generally talked about and yet obstruct decisions. It is easy to think that the best facts are how we make decisions, however this is not what happens in real projects, with real people. So how to understand what happens, and how do we ensure that the best available facts make their way into our decisions? What does “best” mean? All decisions have a unique and rich context. The learnings and tools described in this series are intended to offer new ways of seeing that context and engaging with it meaningfully.

See you in the next post! As usual, please reach out with comments and questions and suggestions for improvements.

The Making of a Decision - Part 3 - Tools for groups

Thu, 15 Jan 2026 00:12:00 +0000

This is part 3 of the series about the common problems found when making architectural decisions, their underlying causes and how to address some of those issues with tools. This post covers tools for groups, such as across teams.

The Making of a Decision - Part 1 - Introduction & Power
The Making of a Decision - Part 2 - Knowledge
The Making of a Decision - Part 3: Tools for Decision Making - Tools for groups (this post)
The Making of a Decision - Part 4 - Team and Personal Tools
The Making of a Decision - Part 5 - Introducing Decision KP Maps

As a side note, I wanted to add that describing a tool in a paragraph or so, is very hard. How to make justice to what comes to hundreds if not thousands of hours of work that went into creating these facilitation tools?

Across teams

The Architecture Advice Process

Overview

The Architecture Advice Process is easy to remember and not so simple (yet very rewarding) to implement. From the book:

A single rule: anyone (a development team member or someone playing a cross-team architecture role) can take (select a decision option) and communicate an architectural decision as long as during the option-making stage, they seek advice from:

Everyone who will be meaningfully affected by the decision Architecture Advice Process People who have expertise in the area in which the decision is being taken

Please note that the decision taker is not obligated to agree or follow the advice - they are required to listen and record the advice.
To support the Architecture Advice Process it’s useful to use Architecture Decision Records (ADRs), Architecture Advisory Forum (AAF), collectively sourced Architecture Principles and a Technology Radar.

Learn more:

📖 Book: Facilitating Software Architecture.
🗒️ A post: Scaling the Practice of Architecture, Conversationally
📹 A video: A Commune in the Ivory Tower: A New Approach to Architecture - Andrew Harmel-Law
👩‍💼 Case study: Decentralizing the Practice of Architecture at Xapo Bank

A related book worth checking out is Continuous Architecture in Practice. The book provides practical guidance on making architectural decisions incrementally, aligning architecture with agile and DevOps practices, and keeping architecture relevant in fast-moving development environments.

Why use this tool? In the context of better decision making

The Architecture Advice Process can help organisations by giving guidance on how to implement ideas that are already familiar to most, but many are inexperienced applying them. You can expect:

Removing bottlenecks. Both top down architecture and hands-on approaches block on people with authority to make decisions. By rebalancing the power dynamics of decision making it is possible to share expertise and remove bottlenecks. If you are curious about what is like to introduce this practise see Elena Stojmilova experience and The Architect’s Dilemma: What to Do When You Disagree With a Team’s Decision
Accountability and responsibility combined. When someone outside a team makes a decision for the team. The implementing team may not feel responsible for the outcome. They might not even implement the decision. This decentralised practice ensures that the person with the need is also the one accountable for the result. The accountability acts as a necessary brake when required.
Open access learning. Anyone interested in a decision can read ADRs or attend the AAF to learn more about how a decision happen.

Team Topologies

Overview

Team Topologies is an approach that helps with structuring teams and their interactions by focusing on cognitive load as well as how and when handovers happen. It defines four forms of teams and three modes of team interactions. Having these patterns available to discuss organisational design helps by providing a clear language to design current as well as possible alternate future states.

Learn more:

📖 Book: Team Topologies.
🗒️ A post: Team Topologies Key Concepts
📹 A video: Monoliths vs Microservices is Missing the Point - Start with Team Cognitive Load - Matthew Skelton & Manuel Pais

Why use this tool, in the context of better decision making

Impact of Conway’s law. “.Organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.” Melvin E. Conway, How Do Committees Invent? Team topologies gives you a tool to leverage this by designing communication structures based on value delivery.
Team autonomy. Organising teams is hard, this technique helps with creating autonomous teams that are aligned on value creation. In combination with the Architecture Advice Process this technique can help unblock teams.
Knowledge sharing within teams with high autonomy is high. Specifically, creating teams to increase knowledge flow is a huge value unlock.

EventStorming

Overview

EventStorming is a collaborative domain modelling tool that helps understand and design complex systems by mapping out Domain Events on a timeline. It’s perfect for kicking off strategic activities and enable a group of people to get in-depth understanding of a domain. It has three well known forms: Big Picture, Process Modelling and Design for different kinds of settings.

See below a timelapse of big picture EventStorming

Your browser does not support the video tag.

Learn more:

📹 A video: 50,000 Orange Stickies Later - Alberto Brandolini
📖 Book: Introducing EVentStorming
🗒️ A post: OPL: Event Storming

Another great book on this is The EventStorming Handbook by Paul Rayner.

Why use this tool, in the context of better decision making

Probably the fastest way for a large group to get cohesive understanding of what the system currently does.
It allows you to learn both about details and about the big picture.
When there are power issues, they tend to surface during the workshop. These are visible throughout but they become especially visible in the voting phase of the workshop.
Synchronising Fragmented Knowledge. EventStorming forces participants from different backgrounds to build a consistent timeline together, ensuring no single person’s incomplete version of the story dominates the decision. Probably the fastest way to establish current state.

More to come…

I hope you enjoyed this post about tools to help with architectural decision making. I would love to hear from you if you have used these tools, what worked for you and what didn’t. The next post is about tools for smaller groups of people.

LAST Conference Melbourne - November 2025

Sat, 22 Nov 2025 00:10:00 +0000

I ran a workshop at LAST Conference on the 21th November. It was my first LAST conference, it was an a great event however it will be my last. Don’t worry! It will be my last one because they have decided to rebrand the conference to be Signal Not Noise.

source

For those of you that attended and requested the slides, or just curious:

I hope to update this post soon with my notes and pictures from the talks and workshop I attended, which I really enjoyed. A special thanks to Michelle Playfair for suggesting this conference and the great team making LAST happen: Lisa Jacob and Ed Wong.

The Making of a Decision - Part 2- Knowledge

Wed, 19 Nov 2025 00:12:00 +0000

This is part 2 of the series about the common problems found when making architectural decisions, their underlying causes and how to address some of those issues with tools. This is part 2, all about what it means to know something, what are useful models to think about knowing something and whose knowledge is accepted. This series covers the topics described in this talk.

The Making of a Decision - Part 1
The Making of a Decision - Part 2 - This article
The Making of a Decision - Part 3 - Tools for groups
The Making of a Decision - Part 4 - Team and Personal Tools
The Making of a Decision - Part 5 - Introducing Decision KP Maps

Part 1 of this series explored how power shapes organisational and architectural decision making by reviewing definitions, laws of power and more. This article focuses on knowledge.

We need to know and understand the context to build good systems. What does it mean to know something? What does it mean to know it in the context of an architectural and system design decision?

“Knowledge sharing is (an essential task of) systems building”

Knowledge sharing is systems building (March 2023)

Understanding Knowledge: The DIKW Model

I spoke with Dawn Ahukanna when preparing this talk. She introduced me to the DIKW pyramid as a good starting model for reasoning about knowledge.

The DIKW model makes it clear that context is the bridge between data and insight. Data turns into information only when it’s interpreted within a relevant context, and it becomes knowledge when that information is applied repeatedly to gain experience. At the top of the pyramid sits wisdom, the least developed layer, demanding moral deliberation and the ability to apply knowledge across situations.

Applying DIKW: A Practical Example

This model might be a good starting point for everyday decision making. For example, imagine you learn that a library your organisation heavily depends on has changed its licence and will soon require a large fee for commercial usage. How can the DIKW model help you guide some of your next steps?

Data. The facts. The licence change to be introduced in the next version includes a large fee for usage in commercial settings.
Information. Adding context. The raw facts are interpreted and linked to the organisation’s own environment. For example, in the near future, the organisation will be liable to pay a significant amount to keep using this library. At this point you should know exactly the cost for a given period. Perhaps you would also know the cost of migrating to another library, although the figure might not be precise. Members of the organisation understand what changed, where it matters, when it will start affecting the system and why.
Knowledge. Understanding and gaining deeper insights. With the contextualised information, some resulting activities might be:
- Conducting a survey of alternative libraries to find viable drop‑in replacements
- Estimating the cost of replacing the library across the organisation
- Considering security risks associated with onboarding a new library
- Looking back at a similar licence changes and its effects within the organisation
- Discussing with product owners, operations, finance, etc to understand acceptable service interruption or other disruptions
- Paying the licence fee
These activities would help build a coherent body of knowledge: the organisation now knows why the change is problematic, how severe the impact could be, and what realistic options exist.
Wisdom. Judgement informed by values and strategy over time. Based on knowledge, the organisation is able to exercise broader judgement leveraging their people. At this point you might consider:
- Creating policies. To avoid future vendor lock‑in, and another policy to monitor critical dependencies with a regular cadence
- If migration to a new library is necessary, provide default paths while recognising that this might not suit all teams and prepare for the extra cost in time and money
- Notifying customers. If it’s deemed necessary, with a brief notice explaining the migration and reaffirming the commitment to security and reliability
- Updating the dependency‑management operating procedure. Reviewing whether a mandatory licence‑compatibility check should be required whenever a major version bump is announced
Wisdom here combines technical facts with ethical, financial and strategic considerations, producing a holistic stance rather than a reactionary fix.

For an extensive analysis of the DIKW pyramid please see: The wisdom hierarchy: representations of the DIKW hierarchy- Jennifer Rowley Bangor Business School, University of Wales, Bangor, UK.

The DIKW model gives us a structure for understanding knowledge. The people involved in deriving it are Knowledge Workers.

Knowledge Workers

People who create software systems are knowledge workers. It’s very likely the person reading this is a knowledge worker.

Knowledge workers are workers whose main capital is knowledge. These are workers whose job is to “think for a living”.

source: Thinking For A Living: How to Get Better Performance and Results From Knowledge Workers. Davenport, Thomas H. (2005).

Our output is primarily thinking. The artifacts we create are in support of that thinking. Our capital, our stock, is the things we know. In the context of an organisation, knowledge work is applying knowledge in such a way that solves perceived or real customer problems.

Given that our main capital is knowledge, how can we share it effectively? How can we reason about using it in the most useful and innovative ways?

A Systems Lens

As Donella Meadows wrote in her book Thinking in Systems:

“A system stock is just what it sounds like: a store, a quantity of material or information that has built up over time. It may be a population, an inventory, the wood in a tree, the water in a well, the money in a bank… Stocks change over time through the actions of flows, usually actual physical flows into or out of a stock–filling, draining, births, deaths, production, consumption, growth, decay, spending, saving. Stocks, then, are accumulations, or integrals, of flows.”

It is surprising that as we are building software systems, we rarely apply systemic concepts to our problems, including knowledge management. Diana Montalion addresses this in her book Learning Systems Thinking. In chapter 6, she invites us to consider:

Knowledge Stock: This refers to the store of knowledge a knowledge worker has developed or can access.

Knowledge Flow: The ability to transfer knowledge between people and people and systems in ways that change and shift the system in an effective way.

As an industry we tend to highly value the stock of knowledge, and not so much flow. Without knowledge flow it would be impossible to build systems. Reading further on this I discovered flow is essential to innovation.

Innovation

Most organisations actively pursue innovation in what makes them unique, as a way to ensure their growth and longevity. Given how critical innovation is to organisational survival, researchers have extensively studied what makes organisations innovative. Multiple papers examine the relationship between knowledge sharing and innovation. The results are consistent. As one study clearly states:

“Knowledge transfer among employees is thought to be crucial determinant of an organisation’s capacity to utilise new knowledge and innovate.”

Source: Relationships between knowledge inertia, organizational learning and organization innovation by Shu-hsien Liao, Wu-Chen Fei, Chih-Tang Liu

As an industry, we have known for many decades that the need for knowledge transfer is essential to build and maintain complex software systems.

Historic Lens: Continuity of the “Theory”

Peter Naur’s seminal paper from 1985, Programming as Theory Building, talks about the importance of people carrying the theory of the program or system:

” Thus, again, the program text and its documentation has proven insufficient as a carrier of some of the most important design ideas”

I want to stress that the paper focuses on core design ideas of a program. The paper continues:

“The conclusion seems inescapable that at least with certain kinds of large programs, the continued adaptation, modification and correction of errors in them, is essentially dependent on a certain kind of knowledge possessed by a group of programmers who are closely and continuously connected with them.”

We’ve known for over forty years that stable teams are essential to maintaining the program theory, especially important as systems grow more complex. Yet as an industry, we keep repeating the same Sisyphean cycle, and act surprised each time the boulder rolls back down. Ironically, we do this in the name of cost effectiveness.

The Hidden Barrier: Who Gets to Know?

Throughout this article, we’ve discussed how knowledge transforms into wisdom and flows through organisations. Do organisations accept knowledge from everyone within? Whose knowledge is deemed legitimate in the first place?

This is an ethical amd practical concern too, directly impacting decision quality. As Iris Meredith explores in “Who has permission to know things?”, corporate epistemology determines which voices are heard and which expertise is valued. When organisations systematically invalidate knowledge they don’t just create workplace frustration, they cut themselves off from crucial insights.

“Knowledge is largely defined and controlled by those in power”

This structural barrier is why many organisations experience sudden “explosions”, accumulated resentment and overlooked expertise finally surfacing when problems become unavoidable. Building better decision making systems requires us to consciously examine: Whose knowledge are we excluding? What is it costing us?

Conclusion

The DIKW model provides a useful framework for moving from data to wisdom. Understanding knowledge workers and the importance of knowledge flow matters for innovation and outcomes, yet many organisations have yet to fully grasp this. At the intersection of knowledge and power sits a crucial question - whose knowledge is accepted? When changing an entire organisational culture proves difficult, recognising the barriers to knowledge sharing offers a practical starting point. Stable teams are essential for preserving the “information theory”, or domain knowledge, of a system. When seeking better ways to manage information, preventing its loss in the first place is remarkably efficient.

As a side note, I’ve long held the intuition that a key indicator of an organisation’s health is the time its people dedicate to learning, particularly when they learn together about their systems, and keep thinking of ways to validate or invalidate this intuition. If you have thoughts or comments about this or anything to do with this article please let me know.
I hope you enjoyed the second part of “The making of a decision”. The next post will be about tools that we can use to improve our decision making in terms of knowledge and power.

Resources and Extra Reading Materials

Core Concepts

The wisdom hierarchy: representations of the DIKW hierarchy- Jennifer Rowley Bangor Business School, University of Wales, Bangor, UK This paper revisits the Data–information–knowledge–wisdom (DIKW) hierarchy by looking at how different textbooks explain the hierarchy in a number of widely read textbooks, and analysing their statements about the nature of data, information, knowledge, and wisdom.
Programming as Theory Building - Peter Naur (1985). Seminal paper on the importance of maintaining program theory through stable teams.
Learning Systems Thinking - Diana Montalion. Explores systemic approaches to knowledge in organizations.

Knowledge and Power

Who has permission to know things? - Iris Meredith. Explores how corporate epistemology and power structures determine whose knowledge is valued.

Decision Making

Slow down to speed up your decision-making - Gien Verschatse

Relationships between knowledge inertia, organizational learning and organization innovation - Shu-hsien Liaoa, Wu-Chen Fei, Chih-Tang Liu. On knowledge transfer as a determinant of innovation capacity.
Charisma in Everyday Life: Conceptualization and Validation of the General Charisma Inventory - Konstantin O. Tskhay et al., University of Toronto.

The Making of a Decision - Part 1 - Intro & Power

Mon, 01 Sep 2025 00:12:00 +0000

This series of posts goes over the topics described in this talk.

The other posts in the series:

The Making of a Decision - Part 1 - Intro & Power
The Making of a Decision - Part 2 - Knowledge
The Making of a Decision - Part 3 - Tools for groups
The Making of a Decision - Part 4 - Team and Personal Tools
The Making of a Decision - Part 5 - Introducing Decision KP Maps

Nearly 30 years ago, I had a great opportunity that might have changed my life in terms of education and work opportunities. The decision, outside my control, didn’t go my way. My family decided that they couldn’t support it. Over time I’ve come to understand their reasoning, though it was difficult to accept when it affected my future far more than theirs. Programming helped me reclaim a sense of agency. I could create something out of nothing.

That sense of freedom and agency diminished as I moved to larger, more complex projects with bigger teams. As software systems grow, they become difficult to change, and more people are involved in making those changes. Remember:

“These decisions are a record of the power structures and the feedback loops that got it there.” -Andrew Harmel-Law

Issues with decision making are more pervasive in the bigger projects, I found again and again issues such as: strong biases for a particular decision, not validating inputs or outcomes, complex processes that promised safety but didn’t deliver and a lot more. The issues were recurring but no clear pattern emerged. People often attribute these failures to ‘politics,’ lack of technical experience, or key personnel departures. These reasons seem to be about dealing with the emotional cost of the decision rather than the underlying problem. I needed to understand more about what is happening and why. Ideally learn about ways to address some of the challenges.

As I started mapping how the people I’ve worked with (and myself) make decisions and what are the types of activities involved, I noticed that there were two key concepts that we use a lot but seem to mean different things to different people: knowledge and power.

Power is uncomfortable to discuss but essential to understand: learning about power is essential to be effective, to be taken seriously and to not be taken advantage of.

There are two key working¹ definitions of power that I find useful:

Power With (Mary Parker Follett)²: “The ability to make things happen, to be a causal agent, to initiate change.”

Power Over: “The ability to make others do as you would have them do.”

Sources of Power

I found the treatment from the book “The Dawn of Everything” most complete and relatable. When transposing the ideas about sources of power from the book over current organisations, we might end up with:

Authority: In organisations, this manifests as economic coercion rather than physical force. It’s the power to fire, demote, or economically punish employees. It can manifest in access control. HR departments and security functions institutionalise this form of control, creating systems of compliance through the implied threat of economic harm.

Charisma operates through leadership appeal, inspirational vision, and personal influence networks. This manifests in leaders who can motivate and direct others through force of personality, compelling vision, or personal magnetism, regardless of their formal position in the hierarchy.

Access to Knowledge appears as information asymmetry and expertise-based authority. Senior management controls strategic information, financial data, and decision-making processes that employees cannot access. Experts wield power through specialised knowledge, whilst administrative systems create bureaucratic gatekeeping around information flow. This mirrors bureaucracy as a form of control over information as described in “The Dawn of Everything”. Knowledge hoarding can become a tool for maintaining hierarchical advantage.

For a study of Charisma see Charisma in Everyday Life: Conceptualization and Validation of the General Charisma Inventory Konstantin O. Tskhay, Rebecca Zhu, Christopher Zou, and Nicholas O. Rule University of Toronto

Laws of Power

There are many books with titles such as: “The n Laws of Power” or similar; they tend to be books about exercising influence, which can be useful. What I’m looking for when I read about the laws of power is understanding why and when power flows. So far I’ve found this to be a useful set.

Power is dynamic. One thing you know for sure is that it will keep changing.
Power is like water. Eric Liu’s metaphor of how power is like water and your organisation is the sponge is very memorable. More from Eric on this:

”.. power is like water. It flows all around us at all times. Sometimes it takes the liquid form of politics-in-action, a turbulent flow with crosscurrents and strong undertows. Sometimes it takes the solid form of settled law: policy is power frozen. Sometimes it is like vapor in the air, invisibly shaping the climate and our behavior in just the way beliefs or ideology or emotions do.” – You’re More Powerful than You Think. A Citizen’s Guide to Making Change Happen By Eric Liu
Power compounds: If you have power you tend to get more power. Small exercises of power create capacity for larger ones.

I hope you enjoyed this first part of “The making of a decision”, the next post will be about knowledge. If you have any comments or questions please reach out via my social links

There is a lot of contention on the definition of power, these are some ways to think about the concept that I find useful ↩
If you have never heard of Mary Parker-Follett, this is a day that can change you. Parker-Follett developed revolutionary ideas about collaborative leadership, power-sharing, and organizational dynamics decades before they became mainstream business concepts. Her central theory, that individuals and society shape each other equally, came from her work in community centers, not the boardroom. Where Taylor and Ford saw hierarchy, Follett saw networks. Read more about it in Dynamic Administration, a book that collected the works by Mary Parker-Follet ↩

Interesting learning resources - August 2025

Thu, 21 Aug 2025 00:12:00 +0000

These resources span from practical case studies in team scaling to theoretical frameworks for understanding programming languages, unified by a common thread: how we structure our thinking to solve hard problems. Whether examining ProTime’s journey from feature teams to domain-owned teams, exploring different approaches to teaching programming concepts, or critically evaluating the models that shape our decision-making, each resource helps navigating the experience of building software.

Scaling Teams with Ownership: A ProTime case study

link

A great example of using DDD. ProTime faced scaling challenges in 2023 as they grew across 40 countries. Their initial “feature teams” model—where small teams worked on single features for 4-6 months before moving to different features—began showing stress with unpredictable delivery times, spread-thin domain knowledge, and a “everyone owns everything” mentality that devolved into “no one owns anything.” This transformation involved workshops across the organisation to redefine team responsibilities and ensure teams were involved earlier in the design process. Six months later, teams with stronger domain ownership showed improved delivery predictability, clearer capacity insights, and better alignment between team capabilities and business goals.

Operational and Denotational Strategies by Noel Welsh

link

Noel is deliberate when it comes to semantics, and this post really shows it. This is about operational and denotational approaches to understanding and exploring programming language concepts. When speaking of operational, this is about how a program executes step-by-step (like walking through function parameter substitution), while denotational explanations focus on what features mean at a higher conceptual level (like describing functions as ways to generalise expressions with changeable parts). He demonstrates this with examples showing how both types of explanations say the same thing but at different levels of abstraction. Might help both when teaching others, and in self-assessment of one’s own understanding.

All posts by John Cutler

link

There is no suitable summary to this. I’ve been visiting this landing page and randomly visiting pages and I learned something every.single.time.

Architecting the uncertain - Getting started with Agile Software Architecture Iteration Zero, C4, Event Storming by Johannes Seitz

link

This post advocates for Iteration Zero approaches, avoiding the trap of traditional upfront design. Software development is fundamentally a learning process and the author recommends incremental, iterative architecture work with the whole team participating rather than dividing work into independent packages. Key activities include understanding system context using C4 diagrams, identifying and rating risks through Risk Storming, understanding business processes via Event Storming workshops, setting up testing infrastructure early, defining quality attributes through scenarios, conducting one-on-one interviews with team members, preparing initial product backlogs through User Story Mapping, building walking skeletons for end-to-end functionality, and maintaining a learning backlog for new technologies and practices. The emphasis throughout is on structured learning rather than big design up front, with the goal of making informed decisions when they’re actually needed rather than prematurely constraining the project. This post seems related to, but different to a post by Hazel Weakly that I come back to a lot.

The Conflict-Intelligent Leader: In these turbulent times learning how to manage disputes is a must. by Peter T. Coleman

link

I highlighted some choice parts of the post to give you an idea of what the post should give you. Talking about the Good-Friday agreement, which was such a meaningful and difficult work on peace is the cherry on the top of this article!

Critically Engaging With Models by Rebecca Wirfs-Brock & Mathias Verraes

link

This needs a post of it’s own! I’m sure I’ll be quoting part of this in the future. To start with a useful definition of model:

“Models, whether for a software system, a development process, diseases, political systems, or otherwise, are a way to look at (a part of) the world. They explain how something behaves and how to modify that behavior. … Models are reductionist; that is, they only show a selection of the subject they’re describing, and lose something in the process. And models are biased: they implicitly reflect the assumptions, constraints, and values of the model’s author.”

These are the heuristics distilled in the post for reference, for full context the original post is the key:

If there are two ways of looking at something, look for a third
Compare different models to figure out what one model adds or omits, emphasizes, or downplays
Understand the underlying belief system that comes with the model
Determine whether the model confirms my existing belief system and values, or conflicts with them
Understand whether the model addresses or solves a problem that I’m interested in solving
Ascertain whether the model points me to problems I might have but haven’t yet considered
Compare different models to understand what you actually care about.
If a model doesn’t explicitly address something you value highly, try fitting in something from another model and see if the model still hangs together.
All models are created within a specific context. Does the original context match yours? Can it be adapted?
When you’re evaluating models, find questions that are relevant in your context, and use them to compare the models.
Are you fitting the model to your context, or are you force-fitting your context to the model?
Be more skeptical of nice models, be more open minded to jarring models.
Models are potentially useful worldviews, not truths.
Does this model help me see something clearly, or does it intend to create a change in behavior?
Find the prescriptions hidden in innocent looking models, and use them to your advantage.
Consider that some models may not actually have been tried by the authors
There’s always another possible model.
Following a model as prescribed is not the same as achieving success.

Also

the post shows how to apply this ideas with an example. Definitely read and bookmark this.

To read

The Three Kinds of Organizational Power by Jacob Kaplan-Moss. I did read this, but given the work I’m doing I need to dive deeper on this, thanks Anja Kunkel for sharing this write up with me.
Navigating Firestorms: The Imperative of Conflict-Intelligent Leadership in a Turbulent World Open Access

Impact Mapping solo

Tue, 22 Jul 2025 00:13:00 +0000

Discovering Clarity Through Personal Practice

I’ve been meaning to do some improvements to the Bytesize Architecture Sessions’ website to integrate what I’ve learned lately, but I wasn’t clear on how to focus on when and how. That changed when I saw Krisztina Hirth’s awesome session: Impact Mapping: The Secret Sauce at Virtual DDD.

While impact mapping is traditionally presented as a collaborative team technique, I find that it’s always valuable to also model things solo. What struck me most was the great value it brought in focussing on outcomes and personas rather than features, making everything measurable by default.

I discovered it works brilliantly to do some work one day, then step away and come back a few days later with fresh eyes. Repeating this cycle several times allowed ideas to percolate and assumptions to surface naturally.

Perhaps the most intriguing aspect of solo impact mapping has been its effect on goal clarity. I’m not 100% sure my goal is good, but the mapping process keeps making me think about it, which feels valuable in itself. The iterative questioning allows me to refine every section of the map with each mapping session. I can gradually build a more robust strategic foundation.

Below you can see the current state of my impact map for Bytesize Architecture Sessions, I expect it can use more iterations.

Please let me know if you see ways the map can be improved.

Resources

Brilliant talk by Krisztina Hirth Impact Mapping: The Secret Sauce at Virtual DDD

Gojko Adzic’s book “Impact Mapping: Making a Big Impact with Software Products and Projects” which provides the foundational theory.
Mark Dalgarno’s comprehensive guide offers excellent practical insights from an active practitioner’s perspective.
LogRocket’s impact mapping guide provides a product management lens on the technique.
For teams seeking maximum return on investment, Mark Levison’s detailed exploration demonstrates how to extract the most value from the process.

Interesting learning resources - May 2025

Tue, 20 May 2025 00:13:00 +0000

These are some readings associated with work associated with Decision KP Maps

Thanks Dawn Ahukanna, Iris Meredith for sharing great resources!!

Who has permission to know things? - Iris Meredith. Touching on Knowledge and power. I have been thinking about this post a lot since I first read it a few months ago. Meredith argues sudden workplace “explosions” stem from “corporate epistemology,” where knowledge is largely defined and controlled by those in power, often disregarding the insights and experiences of minority groups or those lower in the hierarchy. This systemic invalidation of legitimate knowledge from marginalised individuals creates an environment of structural violence, leading to frustration and resentment when their expertise is ignored.

Some notable quotes:

While poisoning one’s superiors isn’t quite so common in corporate settings, this kind of sudden flash of anger often comes up in the workplace

So, what do we find when we look at the average corporate environment? It certainly isn’t that knowledge is built from evidence and reasoned discussion.

…this experience and information that I have, thanks to my position in the hierarchy, didn’t count as knowledge.

Interpretive Labour: Bridging the Gap Between Map and Territory by Shauna Gordon McKeown Interpretive labour is the work of bridging an abstract model and the underlying reality. Privilege and power determine who does that work. The post argues that while this labour is unavoidable, it becomes dysfunctional when it prevents feedback about systemic problems from reaching those who can implement change. The post is rather long, which can be feel like a bit of a commitment, I think it raises some interesting points tho.
Overcoming Alert Fatigue — how to bring reliable observability to an already running production system by Maxi Goschin. The authors highlight three main reasons for this fatigue: annoyance, mental load, and interruptions, all of which desensitise teams to actual issues. Their solution involved a two-pronged approach: firstly, treating every alert as an internal incident requiring immediate action or alert adjustment, drastically reducing “noisy” alerts; secondly, a structured re-evaluation of their observability strategy.
Critical Software Redesign: Creating the Environment for Large Scale Change by Rebecca Wirfs-Brock & Mathias Verraes - Rebecca and Mathias’ writing keeps bringing great insight! The post discusses how to approach major software redesigns within an existing product. Rebbecca and Mathias then proceed to highlight signals, subtle indicators of stress on the system’s design. These should trigger experiments rather than immediate, costly projects. The experiments are great for information gathering, building support, and creating / changing the culture to be more receptive to change, even if they seem unconventional. The post advocates for proactive design leadership ,this is a style of leadership that embraces iterative improvements and continuous experimentation, and also recognises when a fundamental “shift” to an entirely new model is necessary, requiring buy-in across engineering, product, and business visions. This post is followed by a few posts where different people react to signals
Silence Isn’t Consent By Terrence Eden - The gist of the write up is a discussion about how True consent must be enthusiastic and explicit, not assumed from a lack of objection. The core issue is then applied to the digital realm, specifically the behaviour of AI bots that scrape website content for training data.

To read later

These are some posts I’ve been meaning to read in more depth but didn’t get to yet

Scaling Teams with Ownership: A ProTime case study
Operational and Denotational Strategies by Noel Welsh
All posts by John Cutler
Architecting the uncertain - Getting started with Agile Software Architecture Iteration Zero, C4, Event Storming

Decisions KP Map What happens during decision making

Mon, 12 May 2025 00:13:00 +0000

This is a post about understanding what is happening during architectural decision making. Following up from the talk I did at ADA Conf I started working on a mapping tool to help me see and reason what we discussed It’s called Decision KP Map.

Decision KP Map is a mapping tool that helps visualise the subjective perception of the community that enables decision making.The Key People, in terms of their Knowledge and Power. Both concepts together are the source of KP in the name, key people and their knowledge and power.

If you are interested in learning more about it, please see this Introducing Decision KP Maps

I’m currently running a trial to see how it performs. If you are interested please contact me via mastodon, linkedIn or Bluesky.

Thanks Dawn Ahukanna, Kenny Baas-Schwegler , Andrew Harmel-Law and many others that have already given feedback and tried this.

Testing a new modelling retro format - Gaps Growth Great Grind

Sun, 20 Apr 2025 00:13:00 +0000

I’ve been running collaborative modelling sessions lately and noticed that some of the retrospective formats I tend to lean on don’t work as well as it could, perhaps because they have other focus. I was thinking about how to better capture the type of thoughts that come up when you are working through a collaborative modelling session.

So, I be been trying a new format:

🕳️ Gaps: Is there anything not covered by this representation of the system that you think should be there , or it’s not represented well. Example: “We didn’t model feature flags” “No idea what the department adjacent to us do with the data from our systems”
🌱 Growth: Are there some areas here that could give us an edge, alternatively some improvements. Example “Could System A and B send messages via Rabbit rather than have synchronous dependencies”
✨ Great: Reasons you love this system representation or the system itself. Example: “It’s great to see how our systems containers interact finally, I didn’t have a full picture of this”
🚌 Grind:(as in daily grind). These are aspects that create unnecessary friction or complexity. For example are there aspects of the system / this diagram that feel unnecessarily complicated or hard to use or understand. Example: “This system always have items in the DLQ and it’s never clear why… takes a long time to debug” or “The way we are diagramming this is not available to people in external departments”

The format seems to encourage more of the better types of feedback and discussions.

Interesting learning resources - April 2025

Sun, 20 Apr 2025 00:13:00 +0000

A lot of these links are related to learning and collaboration, I blame excellent resources shared by Donna Benjamin, Cat Hicks

Bot Bowl : Bot Bowl is an annual artificial intelligence competition centred around the tabletop game Blood Bowl (from the past). Hard for AI to beat because of the type of game and the fact that is not such a popular game.
Learning about mental models of risk from the Challenger Disaster · Infrastructure: Volume 2, Issue 1 (April 2025) John Flournoy - How mental models of risk held by engineers and managers in the lead-up to the Challenger disaster were different and what the effect of that delta. This reminds me of another paper on risk about mining and a power plant that we discussed online, but what is it???
Leverage Points: Places to Intervene in a System - The Donella Meadows Project - Donella Meadows. This is about the hierarchy of leverage points within a system, suggesting where interventions can be most effective for change. Not new, but good to do another reading as I get better (I hope ) at systems.
Relationships between knowledge inertia, organizational learning and organization innovation - ScienceDirect - Shu-hsien Liao, Wu-Chen Fei, Chih-Tang Liu. This study examines the relationship between knowledge inertia, organizational learning, and organizational innovation in different types of organizations.
Collaboration, Coordination, and Cooperation Among Organizations: Establishing the Distinctive Meanings of These Terms Through a Systematic Literature Review Journal of Management Vol. 46 No. 6, July 2020 965 –1001 - Xavier Castañer, Nuno Oliveira. A review the definitions of collaboration, coordination, and cooperation in management literature, I have not finished reading this but a scan suggest that it would be a good idea if I had more time to work on developing Bytesize Architecture Sessions further.
A Cumulative Culture Theory of Developer Problem-Solving - Dr Cat Hicks. I had the pleasure of hosting Dr Cat Hicks talking about this paper at Virtual DDD and I think her research is something we need to use when thinking about software teams. One of the big ideas of the paper is that we need to start thinking about software development proficiency as shaped by collective learning and cultural transmission, rather than solely individual talent. This is an intuition I’ve held for a long time and it’s great to see research validating it.

Collaborative Drift & Debt: Causes, Symptoms, and Treatments - Elise Keith - Eerily related to the link above but on collaboration. This lengthy post talks about how teams establish working norms and the problems that arise when individual approaches diverge (collaborative drift). The author argues that unaddressed drift accumulates into collaborative debt. Thanks to Donna Benjamin for pointing me to this article.

Tech Waka Podcast & Leadership Collective in Auckland - Learn about your systems for Tech Leaders

Sun, 20 Apr 2025 00:13:00 +0000

I ran a workshop with Tech Waka Podcast & Leadership Collective in Auckland on the 26th March. It was great to get hands on with my new local community!

Thanks everyone that came over and worked hard during this workshop

source

Yow Australia - Talk Slides and bonus links

Fri, 06 Dec 2024 12:13:00 +0000

Some resources that came up either during the workshop or the talk :

Bytesize Architecture Sessions The site with practical information and case studies for Bytesize Architecture Sessions.
Russ Ackhoff “Ted Talk” about systems - A short and rather memorable video about what are systems.
Programmer vs Developer - Einar Host In a team each person has a role, I really like how Einar describes what I think a lot of us that write programs do in a team, and the reason I tend to introduce myself as a Programmer.
Event Storming - Alberto Brandolini - A great workshop format to collectively learn some key elements of your domain.
Programming as Theory Building - Peter Naur(1985) During the workshop we had a moment where we discussed documentation, and having this reference nearly feels like cheating, it’s too well written !

Books

Thinking in Systems - Donella Meadows - Seminal book about Systems and a page turner. It starts off with some basics and quickly gets you to examples that will change how you think, unless you already think in systems, in that case it’ll give you vocabulary.
Learning Systems Thinking - Diana Montalion - The hallway track brought this book to the conversation many times. Sometimes you have a chat with a stranger that changes how you think about certain aspects of your life, the conversation is not always easy but it’s very engaging, years later you still think about that conversation, this book feels like that.
Architecture Modernisation -Nick Tune et al - In chapter 17 you can find the long form of the example I mentioned during the talk… after you pour over that the rest of the book is whirlwind tour of useful techniques for today’s practice of building software
Facilitating Software Architecture -Andrew Harmell-Law Chapter 6 A masterclass on the process of writing an ADR. Since you have the book, you might as well help yourself for a super solid take on one possible way on how to practice software architecture.
Collaborative Software Design - How to facilitate domain modeling decisions Book by Evelyn van Kelle, Gien Verschatse, and Kenny Baas-Schwegler. Not only this is a great book to learn about Collaborative software design, in the tittle after all, it does have sections on Event Storming and it does mention Bytesize Architecture Sessions!

Video and slides for Yow Australia

Interesting learning resources - October 2024

Sun, 27 Oct 2024 12:13:00 +0000

Hartman Proficiency Taxonomy by Maria Hartman - This is about understanding learning, better. The bottom of the taxonomy being called Thought Leader which … not a name that works for me, but I can see where the author is going.
How to build and rebuild trust - Frances Fei - Great talk about how to build trust. There are some gems about why being able to be your true self is important and how it links to what I know as Rhetorical Triangle.
Left-hand Column Created by Chris Argyris. Left-hand Column is a tool that helps you review how you think and feel as you have difficult conversations. The core idea here is to take notes during or after a meeting and record what we think and feel and what we think the others are thinking and feeling. I have referenced this as “Left margin technique” before by mistake, apologies.
Double Loop learning organisations By Chris Argyris More from the creator of Left-hand column.
Psychological Affordances Can Provide a Missing Explanatory Layer for Why Interventions to Improve Developer Experience Take Hold or Fail By Catherine M. Hicks A great paper by Dr Cat Hicks. The paper is about how context makes for success or failure of interventions. Makes sense to me and it’s great to see it validated by research
When (‌modular) monolith is the better way to build software I want to say that this is like having a name for a nice sandwich (which we do). I remember that we need to communicate these ideas and leading by example doesn’t always scale.
Observations on the practice of software architecture - III Great article about software architecture practices (it mentions Bytesize Architecture Sessions)
Liberating Structures - A library of ways to collaborate.
A lisp programming guide By Peter Norvig - I mean, I didn’t know it existed and it was going to be great, right? It is.
How to make small games It starts really well by explaining why this is hard and recommend this read because I’ve been to too many wasted game jams.

To Read

The making of a decision @ ADA Conf Melbourne

Sun, 13 Oct 2024 12:13:00 +0000

These are the slides for the talk I did yesterday at ADA Conf in Melbourne

Posts about the conference

ADA Conf 2024 - Alison Rosewarne Exec Mgr, Architecture at REA Group A complete review from the conference, with summaries for each of the talks. I was super happy to read:

Andrea Magnorsky closed out the day with the final talk – on the making of a decision.

Every talk today was fantastic, but I might declare this my favourite as it packed in so much information and also held me riveted right to the end – at 5:20pm on a Friday afternoon!!

The making of a decision - reading materials

Sun, 13 Oct 2024 12:13:00 +0000

This is a shortlist of what I read to create the talk: The Making of a decision.

Learning Systems Thinking - Book by Diana Montalion
Facilitating Software Architecture - Book by Andrew Harmel-Law
Feminist Perspectives on Power Entry on the Stanford Encyclopedia of Philosophy
Common Ground and Coordination in Joint Activity by Gary Klein, Paul J. Feltovich, Jeffrey M. Bradshaw, and David D. Woods (2005)
Dynamic Administration: The Collected Papers of Mary Parker Follett (1942) Book
Programming as Theory Building by Peter Naur (1985)
Understanding the DIKW Model: From Data to Wisdom by Won-gyung Choi
The effects of expert power and referent power on knowledge sharing and knowledge hiding by Abraham Cyril Issac, Timothy Colin Bednall, Rupashree Baral, Pierpaolo Magliocca, and Amandeep Dhir (2022)
Communication Patterns - Book by Jacqui Read
The Dawn of Everything: A New History of Humanity Book by David Graeber and David Wengrow
Review of Graeber & Wengrow’s The Dawn of Everything: A New History of Humanity by Giulio Ongaro (2021)
Three concepts of power: Foucault, Bourdieu, and Habermas by Gerd Christensen
Mary Parker Follett - Wikipedia
Collaborative Software Design - How to facilitate domain modelling decisions Book by Evelyn van Kelle, Gien Verschatse, and Kenny Baas-Schwegler
Pedagogy of the oppressed by Paulo Freire
Six steps to distributed decision making - Here is where you start if you want autonomous distributed teams

Interesting learning resources - August 2024

Wed, 21 Aug 2024 12:13:00 +0000

Is It Time To Version Observability? (Signs Point To Yes) By Charity Majors
Shorthand and Markup for Speedy Note-Taking - Olaf Zimmermann I thought this was going to be a lot shorter than this. I already use something similar to this but not as consistently as I would like.
Learning Systems Thinking by Dian Montalion I had the good luck of not just meeting Diana but do a workshop together on Systems Thinking at the GSAS.
Facilitating Software Architecture By Andrew Harmel-Law: I have read most of the book and also doing a book club on it. I’m not sure how much useful can I say here except that it’s made me think about how I would like to work a lot.

Interesting learning resources - March 2024

Mon, 11 Mar 2024 12:13:00 +0000

In this post we look at dealing with ambiguity, a high level of what does OODA loops mean, getting better at debugging , and more.

I wasn’t sure how to approach posts from newsletters (some of them behind paywalls). My current standpoint is that if I am able to archive it, then I will include them.

Being a PM at Microsoft: Thriving in ambiguity - By Matthew Roche

This quote is why I wanted to share this article here

… and the following is another good quote

The article main focus is on goals. I enjoyed the examples on how to “eliminate ambiguity” by analysing how aligned are the stakeholders.

Reading about the focus on goals also raises a few questions

How represented other PMs feel by this article? some of this work mentioned here seems more like the type of work a team lead might do or an Engineering Manager.
Is a lot of the work at Microsoft project based? I thought that was not the case but, if not then how does this focus on goals apply to the team dynamics?

The videos are pretty interesting too and it’s a nice touch that they are not just hosted in youtube. Extra internet point to you

What can air combat teach us about software project failure? by Jade Rubick

If you do programming for a living, at some point someone mentioned OODA loops near this is a handy reference to it.

Observe
Orient
Decide, and
Act

Not only does the post does a high level of what OODA loops are but also it helps with reasoning about why small feedback loops (and the correlated corrections) are more likely to lead to success.

Linux debugging tools you’ll love by Julia Evans

If you never came across these zines by Julia Evans aka b0rk I think this might make your day. If you want to learn the basics and also in depth about something, these zines are just so so so good, I am linking to a debugging one because I really liked it but all of the ones I read are brilliant

(Almost) Every infrastructure decision I endorse or regret after 4 years running infrastructure at a startup by Jack

Nice write up with very concrete reasoning. No need to agree with all the points, however great to learn from other’s experience and see how the decisions matured.

How we evaluated the impact of GitHub Copilot for 3 months by Tobias Deekens

It’s what it says in the tin, and it’s valuable to learn from the shared experiences of others. A great addition to this post would be if the surveys included information broken down by programming language and framework. At least in my experience the value you get of CoPilot depends a lot on that.

EDIT: I reached out to the author of this post and it turns out that CoPilot doesn’t break down metrics by programming language.

5 Mistakes That Made My Documents Terrible by Raviraj Achar

This post caught my eye because I could easily relate to the journey the author had experienced. And from there he goes of to suggest how to address the problems. The common problems are about mindset, understanding who you are writing for, clarity of message (where clarity includes brevity) and using visual aids when needed.

Resources for later in the week

An Overview of Distributed PostgreSQL Architectures - Marco Slot seems worth a read
Book Review: Trust in Numbers - Lorin Hochstein
systemd by example
Futurespectives: learning from failures that haven’t happened yet by Neil Vass I heard about this practice before and so it’s time to learn more about it!
Adopting Asynchronous Collaboration in Distributed Software Teams I’m trying to find ways to run Bytesize Architecture Sessions asynchronously and researching options
How to Change a Workshop In-Person Game to a Remote Simulation for Effective Results Started reading one her books and I was impressed, as someone that finds a lot of value in orchestrated collaboration and games, I was intrigued. Also, as above some research material for running Bytesize Architecture Sessions asynchronously.
Managing mutable data in Elixir with Rust by Mike Clarke I scanned this post on the experiment and looks interesting tho I wonder if there are general take away points. When I see projects like this starting I always wonder what happens 3~5 years later who and how this is maintained.
Migrating long running workflows across clouds with zero downtime by Dan Farrelly I’ve written some systems that were long running frameworks before so I’m curious to read this. This is the first time I hear about Inngest

Interesting learning resources - February 2024 - part 2

Tue, 13 Feb 2024 11:13:00 +0000

So here are some interesting links with some commentary about programming languages for distributed systems, cellular architecture, and advisory process for teams.

Programming the cloud ought to be delightful

The article could be summed up with:

Microservices can get complicated
Managing infrastructure is painful and different from programming the domain
Programming languages have a lot of tooling that we can’t use for infrastructure work in a cohesive way

Ideally, it would be nicer if we could:
1. Deploy with a function call
2. Service calls are one line of code
3. Storage is typed too

What happened is that they implemented this ideal into something that you can test, now and for free.

Many concerns come to mind when considering using this in a “real-life project”

Where is it actually deployed and how?
How to implement metrics and logs that one wants? I can kind of guess this, but I wonder if this is part of the language
How to deal with errors?

I am sure a lot o can be answered by playing around with it Still, I might try it out and see what I can learn from it.

Slack’s Migration to a Cellular Architecture - Cooper Bethea

It can be interesting to read these types of write ups. This post goes over:

Detecting failures in distributed systems is a hard problem. Some examples.
Interesting link to a paper on grey failures, meaning a subtle underlying fault. The paper is called: Gray Failure: The Achilles’ Heel of Cloud-Scale Systems Link to paper and how these types of errors generally result in poor performance and other types of inefficacies.
Due to these pervasive grey failures, they decided to make some changes in the architecture.
The post includes some details about the changes to infrastructure.

There were mentions of follow up posts that I didn’t find. I look forward to the next post where the author maybe will describe how they came to these decisions and what alternatives they considered. If you do read the post, you might find some of the images included are a bit blurry, making them hard to read.

Edit: I didn’t know what cellular architecture was. My initial reading tells me it’s a way to contain failure by having partial or full copies of software systems (cloud providers probably love this 💸). Link to aws article on how to implement cell based architecture

Scaling the Practice of Architecture, Conversationally - Andrew Harmel-Law

A blog post I keep coming back to, either to read or share. At it’s core it explains why top-down decision making doesn’t work and what you can get when you work collaboratively. And it’s so well written (yes I am envious!)

The premise is that everyone can make decisions as long as they consult with those affected by that decision and people with experience in that area. There are four activities that support this premise: Decision Records to document decisions, an Architecture Advisory Forum for conversations, Team-sourced Architectural Principles to provide guidance, and a Technology Radar to understand the landscape. Are they all totally suitable to you right now? It depends 😀. It does give you some strong foundations to try for something that works in your teams and organisations.

The article goes over how this affects teams, changes to the role of the architect, how this approach works with the company strategy and how to make it happen. The cherry at the top is an example. At the very worst it will make you think and there are some great external links.

Resources for later in the week

An Introduction to Residuality Theory by Barry M O’Reilly I watched this and I really enjoyed it, I am compiling notes about it, so this is comming on the next post.
Being a PM at Microsoft: Thriving in ambiguity I watched the video associated with this and liked it, so this is for the future too

Interesting learning resources - February 2024

Thu, 01 Feb 2024 12:13:00 +0000

So here are some interesting links with some commentary about programming languages, strategy, etc. Since a lot of the links are not short reads, I’m going to keep it brief.

Rust’s Golden Rule - Steve Klabnik.

The golder rule referred to is the following

Whenever the body of a function contradicts the function’s signature, the signature takes precedence; the signature is right and the body is wrong.

And the implications of applying this to language design and also how it affects language usage. It made me think about cognitive loads when programming and how much I welcomed other decisions in other languages.

Nice to read Steve’s writing. I remember watching some of his talks and what I always enjoyed in those is that it’s an invitation to think. He shows you what he’s thinking and then you are left with more thinking to do, which is absolutely perfect.

The outcome of the strategy becomes culture by Aleix Morgadas

A series of posts about technical strategy. It’s great to see other people’s journeys, isn’t it?
I really enjoyed the raw honesty and self-awareness of the post and the transition to new “levels” of awareness and learning strategy.

This post:

Has a relatable journey
The author acknowledged they hadn’t learn and that they needed to do that (courageous, and also the only way to move forward)
The author strived to find tools than helped them and,
With a nice example it highlights how important context is, you can’t use the same tools in differnt contexts and expect the same results.

It’s a Feature, Not a Bug: A Step-by-step Guide to Architectural Decisions - Sonya Natanzon

I was in attendance when this talk was originally delivered and since then I shared this link multiple times. It’s a no nonsense, well-structured way to find some common ground when making decisions. Like most processes, it’s up to you to find the parts that make sense for your context, and do that.

Watching this talk is especially beneficial if you believe your organisation doesn’t struggle with decision making, as you may discover unrecognized challenges in your process.

Influence mapping series - Charles Lambdin

Not only this is a well written series of articles, influence mapping is a super useful tool.

It’s takes a bit of reading but I think it’s worth it. Not all the examples are ones I would use, however I did enjoy how the larger examples mapped to ideas of what you can do in your situation.

At some point while you read this you might feel rather Macchiavelian but if that is the situation you are in, you might as well have some idea about what tools to use and what tools others are using.

Like most people, I started reading this series on part three. The hook, that kept me reading the series of posts was the many references to other resources.

Resources for later in the week

An Introduction to Residuality Theory by Barry M O’Reilly Heard great things about this and I am going to be missing this at the London DDD meetup so, need to catch this up.
Migrating long running workflows across clouds with zero downtime I have dealt with a similar problem before, curious.

Interesting learning resources - January 2024

Tue, 23 Jan 2024 12:13:00 +0000

This idea, of writing a weekly(ish) post with interesting reads started of after reading Please, Own Your RSS Links. This is a post which could be summed up as

Own your writting so that when stuff goes wrong you can change the source and keep going

Nothing ground breaking but a good remminder to make sure that if you post, put a tiny bit of effort and have an RSS feed. This led me to look for a good RSS reader, which has been hard since google reader died. It also made me realise that not only do I want a reader I want to make some notes for my future self about what I read and what I liked about it, maybe some thoughts.

So here are some interesting links with some commentary

DDD in large product portfolios - Andreas Pinhammer - DDD Europe An excellent video where Andreas goes over a case study of using Event Storming, team topologies and DDD to manage multiple products in insurance. Delivered in an approachable manner.

The Power of Being New: A Proven Recipe for High Impact I really like how the points here are actionable things that you can do on a new or not new gig. I also like that it tells you why it’s recommending each thing, for example

You still have zero prestige among the team, and zero trust; you need to meet them where they’re at and address things they care about.

From Vexing Uncertainty to Intellectual Humility A post from a philosophy professor about his strugles with Schizophrenia, how important is to be with people, and eventually about finding intellectual humility. Very nicely written, the only sour note was would this be posted where it was if this wasn’t who it is?
Postgres Cheatsheet A really handy reference to browse or search when the need arises.

Resources I want to check out

Alicia Juarero at Complexity launch Recomended by several people on different networks. Alicia Juarero is comes across as an academic with deep background on complexity. She wrote Dynamics in Action (2008) and Context Changes Everything (2023). Main reason to check it out: Alicia Juarero is an expert in this area
Tools for Systems Thinkers: The 6 Fundamental Concepts of Systems Thinking by the looks of it this has been around for a while but this is the first time I see this. Main reason to check it out: it looks very promising from my very fast scan

Answering questions about Bytesize Architecture sessions - On the team attitude to collaboration

Fri, 05 Jan 2024 12:13:00 +0000

During October I spoke about Bytesize Architecure Sessions at the Global Software Architecture Summit. I got some interesting questions in the Q&A. We didn’t get through all of them, so have grouped them and answering in smaller posts. This one is about the team attitude to collaboration.

Some collaboration anti-patterns and can Bytesize Architecture Sessions can help?

When people are disengaged or interrupt each other often, these can be signals of team issues, some chaos is to be expected when many people attend a meeting but the patterns are something to pay attention to in the long run.

The questions asked were:

How to avoid people talking on top of each other?

Bytesize sessions are created to be short, the idea being that a group of people doesn’t tend to stay engaged for very long. So, set expectations about interruptions and the duration of the session at the very start of the session, and if you see behaviour you didn’t like say it during the mini retro at the end of the session. I find that these are useful guidelines for all successful meetings of more than three people.

Are there any recommendations for when a team is very apathetic and low energy? How to infuse this energy and willingness to change?

When it comes to apathy, sometimes that happens because people feel like their ideas are not represented. Daniel Minor and others, including myself have experienced that the Bytesize Architecture Sessions can be a great way to have ideas raised by all participants in the session. If you find that the whole team mood is low it might be worth running retrospectives on that particular issue, and act on the feedback received there.

One of the hardest things to do is to interrupt a developer passionatelly explaining their piece. Normally everyone gets too excited during discussions. Any tips on this?

My first instinct here is to focus on setting expectations. If this question is more general and not just about people talking at lenght at the “wrong time” then I am curious: Is this a behaviour everyone in your team exhibits ? If so, it seems that they are modelling their behaviour on someone they are learning from, is that the culture you want in your team? Alternatively, if this is one person, it might be worth having a 1 to 1 and try to explore how they communicate and help them learn about effective communication patterns.

When people in the session have different levels of expertise, how can we make this session work? Less experienced people might fear participation or might get stuck with their design.

I love this question! Bytesize sessions work especially well when there is high diversity of knowledge types.

The time Alone together is where each participant works individually on the same task, allowing them to focus and formulate specific questions. This quiet time is crucial as it provides an opportunity for participants to realize the gaps in their understanding and identify areas for further investigation. Inmediately after that, there is the Consensus part, where the participants pool together to create one model that pools all the knowledge just displayed individually, participants here can choose to be more or less vocal, however their input was seen (and heard) by everyone attending

GSAS presentation video and twenty plus questions about Bytesize Architecture Sessions - The plan

Thu, 12 Oct 2023 13:13:00 +0000

I am just back from the Global Software Architecture Summit were I spoke recently about Bytesize Architecure Sessions. I got some interesting questions in the Q&A. We didn’t get through all of them, so I figured I can answer them in a post.

As I answered all of the questions, I realised that there were many ways to answer them, and that in many cases that was very useful too. So, I am going to answer a question or more (if they make sense together) per post, to keep it interesting.

Below is the list of questions. If you have more questions please send them to me via mastodon or LinkedIn and I can add them to this list.

Questions about number of participants

How many people should participate on a Bytesize Architecture Session ideally?
What should be the maximum size of people attending a Bytesize Architecture Session?

Questions about the goal of a session

How many sessions/weeks does it usually take to complete?
How to narrow the goal of the session to a specific case? How to reach a goal when the issue is is too big?
Let’s imagine that part of a team has implemented a few new services How do we share the knowledge with the rest of the team using Bytesize Architecture Sessions?

Questions about team’s attitude to collaboration

How to avoid people talking on top of each other?
Are there any recommendations for when a team is very apathetic and low energy? How to infuse this energy and willingness to change?
One of the hardest things to do is to interrupt a developer passionatelly explaining their piece. Normally everyone gets too excited during discussions. Any tips on this?
When people in the session have different levels of expertise, how can we make this session work? Less experienced people might fear participation or might get stuck with their design.

Questions about where does Bytesize Architecture Sessions doesn’t work as intended

Have you experienced this approach fail or not work as intended for the specific task at hand?

Questions about the “Consensus” part of the Sessions

The idea that consensus is not only about agreement, but also about disagreement is very interesting. Was this a learning from the first sessions or does it come from somewhere else?

Questions about the specifics of Bytesize Architecture Sessions as a tool

What makes Bytesize Architecture Sessions different?
How is this collaboration tool different from Event Storming?

Questions about companies using Bytesize Architecture Sessions

Are there any companies using Bytesize Architecture Sessions?

Questions about Bytesize Architecture Sessions and do people forget between sessions

Do people forget what was done in the previous session?

Questions about Bytesize Architecture Sessions and decision making

Isn’t this technique favouring an organic architecture growth by making collaborative decisions around out of expertise areas?
In terms of technical details of the architecture that require in-depth technical discussions How can developers and architects benefit from Bytesize Architecture Sessions to improve alignment of their ideas, have you experienced this?
Responsibility for architectural decisions should be fully taken by the architect. This format could imply shared responsibility with the team. How do you avoid that

Questions about Bytesize Architecture Sessions and alternative formats

Why not ask people to come to the meeting with a proposal instead of letting everyone start thinking about the problem when they get into the meeting?

Questions about Bytesize Architecture Sessions and other tools

But we still need to write ADRs, don’t we?

Questions about facilitating Bytesize Architecture Sessions

Who facilitates the Bytesize Architecture Sessions? How do you guide people to reach Consensus

Questions about the cost of Bytesize Architecture Sessions

Do you use this format in practice? it looks like it would costs too much time (& money) to include the whole team

GSAS presentation and twenty plus questions about Bytesize Architecture sessions - The plan

Thu, 12 Oct 2023 12:13:00 +0000

About the number of participants

How many people should participate on a Bytesize Architecture Session ideally?
What should be the maximum size of people attending a Bytesize Architecture Session?

For a new group of people trying out Bytesize Architecture Sessions, the maximum number of participants is somewhere between 6 and 10 people, depending on the group dynamics and experience modelling together.

If you have less people, things work just fine, I ran sessions with 3 people and it works in that it allows people to collaborate with some framework.

Other people using Bytesize Architecture Sessions have experimented with numbers of participants, and they they found it as useful with one person and groups. Link to article

Why nine or less?

A session lasts between 45 and 60 minutes:

When there are more people is unlikely that the participants have enough time and attention span to do Alone Together well, nevermind the rest of the session.
Hard to “known when to speak”, so many will remain silent.
It’s hard to not talk accidentally on top of one another

I’ve experienced teams resorting to “just have some people listening in”. Don’t! It really changes how the sessions feel, they become performative.

What if you have more people?

And the answer is: it depends on the problem you are trying to solve.

If you have a complicated team collaboration, you might want to choose a pair of people from each team to try to navigate to the solution over a series of Bytesize Sessions.

If your team is bigger than that, it might be a good time to think about where are the silos and why are they there. When it comes to teams configuration, a good resource to check out is Team Topologies

If you have a bigger problem maybe you need to try other modelling techniques first and then, try some Bytesize Sessions.

Remember, team configuration is software architecture too!

PS: Thanks Jacqui Read for the suggestion to group the posts by topic.

Answering questions about Bytesize Architecture sessions - On the goal of the sessions

Wed, 11 Oct 2023 12:13:00 +0000

I recently spoke about Bytesize Architecure Sessions at the Global Software Architecture Summit. I got some interesting questions in the Q&A. We didn’t get through all of them, so have grouped them and answering in smaller posts. This one is about how to find the goal of the session.

Questions about the goal of the session

How to narrow the goal of the session to a specific case? How to reach a goal when the issue is is too big?
How many sessions/weeks does it usually take to complete?
Let’s imagine that part of a team has implemented a few new services How do we share the knowledge with the rest of the team using Bytesize Architecture Sessions?

All these questions are similar in that we are trying to understand how much work to attempt to do in one session, as well as to try to finish something across sessions.

Let’s start of with the bigger picture, what are you trying to achieve with these sessions.
If you are trying to get a team to be more homogeneous on their knowledge of their domain, then you can think about ways to break that up into diagrams that can be roughly drawn in 5 mimnutes, this is why I always suggest to start with C4

For example in one of the first teams we tried Bytesize Sessions, as a team each of us knew some of the workflows well, but each of us didn’t know all of them, and we had no diagrams for them. So, in each Bytesize Session we did boxes and arrow diagrams of the workflows, one diagram per Session.

If we now focus on the how much the participants can model in one session. To answer consider

What can be modeled in the few minutes that you have set for Alone Together
How much experience do the participants have
If you are not sure, think about what you need, then try it yourself, with less time(maybe four minutes instead of five)

As you iterate with the Sessions’ participants you will all start getting a feel for what you can do.

Bytesize Architecture Sessions help you evolve an Architecture practice, in a safe space.

New Crafts Paris May 2023

Tue, 23 May 2023 03:48:00 +0000

I am going to be talking at New Crafts this Friday. I’m planning to update this post with more info about how was the conference here, so I figured I will start this post now.

Abstract

People building a (dynamic) system need to have a high level of shared knowledge. They need to know not just what to build today, but what the system should look like in the near future. Generally, the goal of the system is a bit of mirage, with blurry edges. We have an idea of what it is we are building and we build that together but details are hard to grasp.

Sharing knowledge effectively is hard, in this talk I will present a technique called Bytesize Architecture Sessions. It is a workshop format that improves knowledge sharing of systems.

Some of the benefits of Bytesize Architecture Sessions are:

Improved systems thinking.
Enriching collaboration within the team.
Understanding architecture practices and tools in a safe environment.
A feedback loop controlled by the team that produces better documentation across sessions.
Revealing the Bermuda Triangles!

Since you are here you get a peak at one of my slides!

Tips for your first technical conference (Non-academic) 2023

Tue, 23 May 2023 02:48:00 +0000

I am going to be giving an in person talk after a long time (at New Crafts, more info ), and I was feeling a bit anxious. If I am feeling like that, how do people that never attended one must feel?

My advice

Bring

Comfortable footwear. You’ll be standing and walking for a lot longer than you planned 👟
Water and snacks. Especially water. There is food and drink in the conference but not always when you need it 🚰 🥜 🍏
Plasters and something for headaches. Especially the plasters can be life savers (for those of you that didn’t bring comfy shoes) 🩹 💊
Some questions you can ask random people so that you have an excuse to meet them 👋

Don’t bring

Work ( don’t try to do your normal work as you are in the conference, you kind of do neither well) 🏢 🛑

Outsourced tips

I reached out for advice and got a lot of helpful ideas that are beneficial for both first-time attendees and speakers. Since the information is spread across a few sources, I figured it would be convenient to gather it all here.

🕰️ Take breaks. Go outside the venue for coffee. Find some quiet. Go to a park if there is one nearby. Go to your hotel room and stretch out for a while. Einar W. Høst
📇 (This is more for commercial conferences but the sentiment applies) You’re going to meet a lot of people. If you’re handed business cards - once the person is away - use the empty space on the card to write a small note on who the person is, and if you were meant to act on it somehow (write them an e-mail, etc). Manuel Correia

These are speaker specific

🐈 Ideally bring a friend, someone you can use as an anchor between sessions. If you’re a speaker, have a friendly face aka a nodder on the first row. Einar W. Høst
🇦If possible, check your own slides in the room you are going to speak, perhaps in a lunch break. Plug in and go sit on the back row. Does it look good? While you’re doing the talk is not the right time to find out that you chose the wrong font size. Einar W. Høst
🔥 Warm up, get into a rhythm of speaking 30 minutes before you start… to avoid a cold start. Your best enthusiasm and ideas will come 5-10 mins anyway, so give yourself a running start Adam Murray
😸 Tell a story and include something funny. Maybe the story fits with the conference theme, the track in which you are speaking, or your talk alone. If you aren’t sure that your punch line will be funny, be sure to have a follow-up that will make it funny. If you get a laugh with the first, the second will also work. It will relax you and draw your audience into your topic, giving you confidence. Most tech people love savvy humor, and the story will help people remember your talk and your light personality. Vaughn Vernon
Doing something to relieve tension and nervous energy before speaking might also be good. I tend to stretch a bit and walk around the room, talking a bit to myself like a madman. I have many times thought that sounding a barbaric yawp over the roofs of the world is what I really should be doing before a talk, but I haven’t gone there yet. Einar W. Høst

Knowledge sharing is systems building

Fri, 31 Mar 2023 02:48:00 +0000

It is not uncommon to hear the parable about the blind people and the elephant when learning about systems. It’s a story about a group of blind people who have never come across an elephant before, and who learn and imagine what an elephant is by touching it.

As I spend more time running Bytesize Architecture Sessions and thinking about systems in general, I am coming to the (not so surprising?) conclusion that the act of successfully sharing knowledge is an inextricable part of building systems.

If we needed a metaphor for the act of building systems, it would be something like: A group of blind people imagine something similar to an elephant, maybe someone even heard about elephants once, and they only have the shadow of an elephant to guide them.

After some consideration they decide they want to create an elephant, it takes time and effort and then at some point “it goes live”.

When a group of people decide to start building a system, and as they continue, what they are building will be a bit of a mirage. It will be not clear and they are only likely to succeed in building something useful if they communicate and collaborate on what their building.

We need collaboration to bring something to life, and even more to keep it alive.

Bytesize architecture sessions - Why start with C4 Diagrams

Mon, 26 Dec 2022 12:48:00 +0000

In my previous post about Bytesize Architecture sessions I described briefly that one of the key aspects of the session is to have time “Alone together” where each of the participants of the session will have a few minutes where they are in the same room working on the same task, but not collaborating. What I did not mention was what to do. This post fixes that.

When I started running sessions I noticed that if you ask people to draw the system without any constraints each person draws at different levels of abstraction, some will add a lot of low level details, some will do a bit of high level and a bit of low level… most won’t be able to finish which is not ideal.

I suggest drawing what is known as a Context Diagram of the system as is right now. A Context diagram is the top level of the C4 model. C4 is a modeling technique for describing your system at different abstraction levels.

If you are wondering why drawing the system as it is right now, these are a few reasons

It is important to anchor the diagrams in reality. This means that it’s possible to check if the diagrams are correct.
Any architecture effort needs information about the current state of the system, what better place to start than drawing something everyone knows about.

If your team is not familiar with C4, teach them about it before a Bytesized Session. I find that most teams get there fairly fast with very little coaching.

Example of a Context Diagram. Source: C4model.com

If your system is too big and you think it won’t be possible to draw the whole Context diagram in one session, then break it up. Once you have a Context Diagram, it is a good idea to continue with the other parts of C4, at least do Container and Components.

Case study: The digital transformation of Santa's logistical nightmare - Part 2

Thu, 22 Dec 2022 08:48:00 +0000

Note: This is a cross post from Functional Feline Society, a collaboration between Elias Court and Myself.

Welcome to part two of the series. “A series?”, you ask. Read all about it by following the link to part one.

In this blog post, we’d like to go through how Santa’s workshop makes use of cats-effect (CE3) to bootstrap itself.

Before we get started, we want to say that the Typelevel documentation on cats-effect is very complete and well written - so we strongly recommend reading through those if you haven’t had any exposure to cats-effect.

With that out of the way, let’s get our paws wet and see how we can leverage CE3 to wrangle together all these side effects in our Main class.

One of the first things you’ll see is that this isn’t a regular scala App but instead extends IOApp.Simple. This provides us with an entry point to our application which will evaluate an IO[Unit] that we give it. It is also capable of handling interruption signals by cancelling our application and releasing resources. If you need access to either program arguments or the ability to return a specific exit code - you’ll need to look at the standard IOApp variant.

import cats.effect.{IO, IOApp}
object Main extends IOApp.Simple {
  override def run: IO[Unit] = for {
  //...

Carrying on to the definition of loadKafkaConfigFromEnv (see below) of Main.scala, we have some code that loads the necessary environment variables and if not those values are not there the whole application will fail with a MissingConfig error. We also want the return type of this definition to be IO[KafkaConfig]. A more common approach for production apps and configuration values is to use libraries such as Ciris or PureConfig.

  private val loadKafkaConfigFromEnv = for {
    maybeBootstrapServers  <- Env[IO].get("BOOTSTRAP_SERVERS")
    maybeSchemaRegistryUrl <- Env[IO].get("SCHEMA_REGISTRY_URL")
    kafkaConf <- (maybeBootstrapServers, maybeSchemaRegistryUrl)
      .mapN((bootstrapServers, schemaRegistryUrl) =>
        KafkaConfig(bootstrapServers, AvroSettings(SchemaRegistryClientSettings[IO](schemaRegistryUrl)))
      )
      .liftTo[IO](MissingConfig)
  } yield kafkaConf

To read environment variables we use Env[IO] which is part of CE3 and it’s there for that very reason, pretty handy. On the second and third lines of the code above, we have the two Option[String] environment variables that we need to combine to complete our configuration - here you can see us using mapN to combine the options. We want our app to fail bootstrapping if the configuration is missing, so we use liftTo to convert Option.None into an IO.Error(MissingConfig).

Coming back to the definition of run, the last thing we want to do is initialise our application’s resources and run it forever until it receives an interrupt.

  override def run: IO[Unit] = for {
    _         <- IO.println("Loading config from ENV...")
    kafkaConf <- loadKafkaConfigFromEnv
    _         <- IO.println("Starting service...")
    _         <- SantasServer.resource(kafkaConf).useForever.void
  } yield ()

We do this by passing our configuration to SantaServer.resource which returns a Resource[IO, Server]. We allocate our resources and allow the program to run until terminated by calling useForever on the Resource(There will be more on using Resource in other posts). One minor thing to note here, is that we call .unit afterwards - this is because useForever has a return type of Nothing to indicate that the code will never return normally and this triggers a dead code warning from the compiler. We could refactor the code or use a no warning annotation here, but we opted for .void to change the type to IO[Unit] instead. As part of the application shutdown, finalizers run for the resources we initialised. This means all resources related to Kafka Consumers, Http4s Server, etc are all cleanly terminated… which is Nice. You’ll likely run into Resource quite often and it is talked about in the CE3 documentation we mentioned earlier, so if you’d like to learn more we’d recommend checking it out!

Notes

Soon after starting we had to decide what style to write our application in. You’ll frequently come across a pattern called ‘Tagless Final’ where implementations are expressed with an abstract F[_] effect type and dependencies commonly injected as context bounds. We chose not to do this and to write our code directly against IO[_] to make the examples more accessible.

In our example you will see IO as a type parameter to many traits. Some of them defined by libraries (like in the case of Env) and some are defined by us, type parameters work as usual and also they are sign of how we want to deal with all side effects.

Cat Tax!

You made it all the way to the end!! wooo! Here is a picture of us! (the authors of this post!!)

Dog & Bones

Megachu

Case study: The digital transformation of Santa's logistical nightmare

Fri, 16 Dec 2022 12:48:00 +0000

Note: This is a cross post from Functional Feline Society, a collaboration between Elias Court and Myself.

Introduction

This is the first post in a series walking through an example of a microservice with a Kafka integration using the Typelevel stack. We have chosen to showcase a simplified version of Santa’s Ledger. If you want to see the repo now, click here. Unbeknownst to most, Santa’s systems are actually supported by cats (the ones that go meow). The work here was kindly translated into English by our keepers.

Megachu

Bones

Dog

Summary

This series of posts is a report on our experience building and running Santa’s Ledger, a well known, reliable system of gifting. One component of this report is a toy version of the real system designed for didactic purposes. This toy repo has representative examples of:

Using IO rather than a finally tagless approach because we thought it might be easier to read for people not used to more functional approaches. Feedback on this most welcome
- Click here for an example
Consuming messages off of Kafka
- Click here for an example
Serializing and deserializing messages using codecs defined with Vulcan
- Click here for an example
Maintaining concurrency-safe state using Ref from the cats-effect standard lib
- Click here for an example
Routing using HTTP4s
- Click here for an example
Writing tests using munit
- Click here for an example
Using docker containers for integration test dependencies with test-containers
- Click here for an example

To keep the toy project simple and to the point, there are a series of decisions and assumptions we have made. Please see #Decisions & Assumptions for details.

Motivation

Some of our keeper’s friends, who are coming from Akka and Alpakka, asked us about how to integrate with Kafka using the Typelevel stack. We decided an example would be a great place to start.

We looked but in our (not overly extensive) search we were unable to find a recent and succinct example of the above and set off to building one!

More importantly, it’s 🎄Christmas-time 🎄 and 🎅 Santa 🎅 needed a digital transformation.

Requirements

With this example we aim to demonstrate the consumption of kafka messages, maintenance of local state and running an HTTP server using the Typelevel stack. The requirements are as follows:

Santa’s Address Book should process and store information about the latest address a kid lives at.
Santa’s Ledger should process information about a kid’s behaviour and keep track of what present they should receive.
Santa must be able to query the service for a kid’s address and the present they should get. (a.k.a. A consignment)
Santa must be able to query the service for all consignments destined for an address.
- This is to avoid costly repeat trips to a household. (Rudolph gets a bit tired…)

Decisions & Assumptions

You have some familiarity with Scala.
Last names have a 1-to-1 mapping with address and full names are unique (everyone is very original in this world)
Addresses are strings, because Santa and their team are very consistent with addressing and we didn’t want to model this.
You already know Kafka and how it works. When we had to make choices about what settings to use we chose whatever made the example easiest to understand.
You already know how to write tests. We are not aiming to demonstrate good testing practices.

What’s next?

We’ll dive deeper into some of the technologies used over a series of blog posts throughout the festive period. If you have any preference in order, please let us know.

This blog post was supervised by Andrea Magnorsky and Elias Court

Bytesize architecture sessions -The power of Alone Together

Sat, 01 Oct 2022 12:48:00 +0000

In my previous post about Bytesize Architecture sessions I described briefly that one of the key aspects of the session is to have “Alone together” time where each of the participants of the session will have a few minutes where they are working on the same task but not collaborating , and they are in the same room (virtual or not).

The quiet time allows a break to engage on the task at hand and have some time to think (time to think during a meeting is sadly underrated ). Because of it, each participant learns to:

Realise that sometimes they don’t have the full picture, and come up with concrete areas for further investigation .
For people new to the team or system, it builds confidence in what they have learned by revising what they know. New people generally bring great questions. The questions some might have anyway but are tired of asking, or afraid to ask.
For some people with less confidence or experience, they generally realise how much they do know. It also has the effect of building on that experience since, this is a systems thinking exercise, with a very low failure risk.
Finally, with some iterations, the group can see that they have more or less homogeneous knowledge, and don’t need to always lean on the same people
It helps people that find it hard to engage on fast interactions ¹

Meetings are generally not very effective, getting all of that in a few minutes is the power of Alone Together

Thanks Tolga Sofuoglu for your feedback. ↩

Talk-The best Lifehack but for your software

Wed, 17 Nov 2021 20:48:00 +0000

I did at talk about tools of software architecture 🎉.

As a programmer you make architecture decisions all the time, whether you like it or not, might as well have some tools to help you with that.

My aim was to show the tools based on their value, there are excellent resources out there to learn how to use them

The tools:

🔧 Understand the problem: Domain storytelling, event storming, impact mapping, etc
🔨 Understand the systems and their context: C4, UML sequence diagrams, CRC, etc
🪚 Record expensive decisions: ADRs
⛏️ Analyse your current context and strategy: Wardley maps
🪛 Keep doing all the above: Bytesize Architecture Sessions you have all the tools above. When do you do this how do you keep it up to date? The recommended format would need some modification if you do workshops formats.

I will link to the recording when it becomes available Presentation Pdf

Resources

ADR resources and tooling
Bytesize Architecture Sessions
The C4 Model for Software Architecture
Domaing Storytelling:
Systems and Architecture
- Key characteristics of systems Russel Ackoff 10 min video
- What is architecture?

Bytesize architecture Sessions

Tue, 28 Sep 2021 20:48:00 +0000

Update: see Bytesize Architecure Sessions website bytesizearchitecturesessions.com 🎉

The more you do something, the better you get at it. It applies to software architecture too. How to do it more often?

People new to a codebase and those less experienced with programming generally have incomplete or incorrect mental models about the codebase. One would expect that as time passes, the mental models should become correct, how about being more deliberate about it?

Here is an easy to try option: Run a Bytesize architecture session:

An hour long recurrent meeting with your team. Bi-weekly at the start and you can phase it to once a month as people run out of things to draw.
Decide together a subset of the architecture you want to draw. This is not a test, it’s an opportunity to learn together about what you know and, most importantly, what you don’t know.
Set a timer for 5 minutes.
Separately, everyone draws in a piece of paper, this is “Alone Together” time. If you don’t know something, leave it blank.
When the timer goes off show each other what you drew. Yes, it’s kind of scary.
Discuss and find consensus on what is the resulting diagram should be. Finally record the diagram(s) created somewhere (e.g: draw.io, miro, plantuml, etc)

It is normal to forget some parts. Together you can make a better picture.

Outcomes

Understanding of whatever you decided to focus on the session will increase. Now you have concrete questions, and generally you can find the answers in the code.
Deliberately thinking about architecture with a cadence keeps the ideas fresh in people’s mind.
The resulting diagrams become a design tool that is inherently familiar to the team, since they created it.
The resulting diagrams highlight obvious areas for improvement.

What do you need to run a session

Cup of tea / coffee / water
1 hour with your team
pen and paper or an online board
Psychological safety (essential)

What is this practise trying to address

In most teams there is at least one person that has a high fidelity image of the architecture in their heads. It is common for other people in the team to defer questions and decisions about the architecture to that person, this is great (is it tho?) until that person is not available.
If everyone in the team has the same or similar picture of the architecture in their heads, they will make better decisions on their day to day.
I have tried this for a few years and it has proven super useful. Teams are happy to build this together and get a feeling of ownership.

Chasing a trail or chasing our tail History of .net from a PL perspective

Wed, 16 Dec 2020 20:48:00 +0000

Using .net as an example we’ll go over the technical decisions that influenced how todays languages look like. We will look at some key technologies that enabled the creation of .net, the reasons for its creation and the origin of its core features.

Video of the conference (with video starting with at my talk. The whole conference is in that video) :

I have created the following diagram to make following the topics of the talk simpler. There are many ways to link these, and

Resources

Microsoft early history

Microsoft: key facts- Irish Times
History of Microsoft - Wikipedia
The History of .net from Richard Campbell from .Net Rocks

Virtual Machines

Many BCPL papers and links by Martin Richards
Z-Machine talk by Ross McKinlay
https://en.wikipedia.org/wiki/UCSD_Pascal

ML family of programming languages

Java and the JVM

Lighting and early days of .Net

The history of C#
History of F# by Don Syme
Interesting discussion about tail calls in C#
History of Mono
.NET Framework

.NET Generics

Don Syme and F#

History of F# by Don Syme

Other resources

(The evolution of C#: Lead designer describes modernization journey, breaks it down about getting func-y)[https://www.theregister.com/2020/11/11/the_evolution_of_c_lead/]
Why No One Uses Functional Languages. / Wadler, Philip. In: ACM Sigplan Notices, Vol. 33, No. 8, 08.1998, p. 23-27.
Why hasn’t functional programming taken over yet The answer by Eric Lippert in this thread

Final words

If you enjoyed this talk and the subject, I have done some other talks about history and philosophy of Programming languages:

Be warned, history of PL is an appealing rabbit hole. If you want to delve (a lot) deeper into the history of PL the whole series of books on based on the HoPL conferences books are a great resource.

Timer with Cats Effects

Mon, 30 Nov 2020 20:48:00 +0000

Not so long ago, I had to add a feature that should run periodically as part of a web-server. I thought, no problem, I will use cats effects that will run whatever I need on a separate thread and return once completed. I was wrong …

My initial program looked something like this:

object TimerInitial extends IOApp {

  def periodicReminder(implicit contextShift: ContextShift[IO]): IO[Unit] = {
    println("from periodic ")
    timer.sleep(1.second).flatMap(_ => periodicReminder)
  }

  override def run(args: List[String]): IO[ExitCode] =
    for {
      _ <- IO(println(s"Before"))
      _ <- IO.shift *> periodicReminder
      _ <- IO(println("After"))
      _ <- IO.sleep(5.second)
      _ <- IO(println(s"end"))
    } yield ExitCode.Success

}

What I was trying to achieve was that it will print:

Before 
from periodic
After
from periodic 
from periodic 
from periodic 
end 

Process finished with exit code 0

However what I got was:

Before 
from periodic 
from periodic 
from periodic 
from periodic 

//until I stopped execution

This is not ideal but why is this happening? In the for comprehension there is a call to IO.shift, and given the rest of the code, we switch context to where the method where we have a timer and there is nothing to bring us back to the context of the main run method.

So I thought, maybe something can bring the context back, I tried IO.delay which Suspends a synchronous side effect in IO. Which is not really what I needed to do.

object ThingWithTimer extends IOApp {
  def periodicReminder(implicit contextShift: ContextShift[IO]): IO[Unit] = IO.delay {
    println("from periodic ")
    timer.sleep(1.second).flatMap(_ => periodicReminder)
  }

  override def run(args: List[String]): IO[ExitCode] = {
    
    for {
      _ <- IO(println(s"Before"))
      _ <- IO.shift *> periodicReminder
      _ <- IO(println("After"))
      _ <- IO.sleep(5.second)
      _ <- IO(println(s"end"))
    } yield ExitCode.Success
  }

}

The results of running this were however a little closer to what I was looking for in that the context returned to the main run method:

Before
from periodic 
After
end

Process finished with exit code 0

So, what we were looking for is a method called background which returns a resource that will start execution of this IO in the background. Which is pretty perfect for the kind of task this needs to do.

object TimerBackground extends IOApp {

  def periodicReminder(implicit contextShift: ContextShift[IO]): IO[Unit] =
    for {
      _ <- IO(println("From periodic "))
      _ <- timer.sleep(1.second).flatMap(_ => periodicReminder)
    } yield ()  

  override def run(args: List[String]): IO[ExitCode] =
    (for {
      _ <- Resource.liftF(IO(println(s"Before ${ZonedDateTime.now()}")))

      _ <- periodicReminder.background
      _ <- Resource.liftF(IO(println("After")))
      _ <- Resource.liftF(IO.sleep(5.seconds))
      _ <- Resource.liftF(IO(println(s"end ")))
    } yield ()).use(_ => IO(ExitCode.Success))
}

And I think that is all for today, till the next time.

Running scala steward on private repos

Sat, 15 Aug 2020 20:48:00 +0000

Motivation

Keep the dependencies in many repositories up to date as automatically as possible. Warn me when they can’t be updated automatically without breaking the build.

How to run

You can run by cloning the repo and running it, check the instructions.If you want to run this on private repos on some CI I find that it might be easier to run from Docker. I especially like that you can use a particular version you know works and move when you are ready.

To run from Docker, execute something like this from where you checked out scala-steward(setup the necessary env vars STEWARD_DIR, LOGIN and EMAIL accordingly):

docker run -v $STEWARD_DIR:/opt/scala-steward -it fthomas/scala-steward:latest \
  --workspace  "/opt/scala-steward/workspace" \
  --repos-file "/opt/scala-steward/repos.md" \
  --default-repo-conf "/opt/scala-steward/default.scala-steward.conf" \
  --git-author-email ${EMAIL} \
  --vcs-api-host "https://api.github.com" \
  --vcs-login ${LOGIN} \
  --git-ask-pass "/opt/scala-steward/.github/askpass/$LOGIN.sh" \
  --sign-commits \
  --env-var FOO=BAR

Let’s break this down

The first few options are for docker to run and mount the current directory as a volume then there is the scala steward options:

workspace: where all the repos will be cloned, etc.
repos-file: This is a file with a format like ` - user/repo` per line. These are the repos you are asking scala steward to keep up to date.
default-repo-conf: This is an optional argument. I haven’t used this but seems to be about pull request frequency, commit messages, etc.
git-author-email: The email that will be used in the commit.
vcs-api-host: Generally it will be "https://api.github.com" the url of the api of the git host server. AFAIK github, gitlab and bitbucket supported so far.
vcs-login: the username of the git account
git-ask-pass: I found this kind of strange, and ~have to wonder about alternatives~ this is why. This is for the path to an script file that returns: the plain text password :( or an authentication token. The script must start with !#/bin/sh. For this, since running this internally, I create the file on the fly with information available in my CI environment, similar to what how it is described ine the link above.
sign-commits: I don’t use this. Might be useful in case one wants to sign the commits.
env-var: if you need to add any extra environment variables so that the repos run.

Now that you have Scala steward set up you might want to select a test repo to update. Before you add that to the repos-file set up pull request building in your CI or externally. There are many options here, I tested a jenkins plugin (it was painful and didn’t work well in my case), Aws CodeBuild and Github Actions. The last two were pretty painless.

Optionally you might want to also set up Mergify or something like that, to automatically merge certain PRs.

Depdendency Management over time

So with PR building set up you might be tempted to add all your repos at once. That might be a bad idea. This tools creates one PR per change, it is very likely you might want to update many libraries at once. To know what is out of date you can simple use sbt dependecyUpdates Also you don’t want to block CI for a while (if that is your setup). I suggest you add a few repos at a time and see what happens. This is a good task to do while waiting for something else.

source: https://xkcd.com/303/

Since not so long ago Scalafix updates are enabled by default, a nice enhancement. Also you can add your custom scalafix changes.

Please note, you can set up configuration per project if you want to stop particular updates. If you have questions, the FAQ is pretty good.

Some other ways

Since this is all about managing dependencies, these are some interesting projects that I am planning to check out(but haven’t yet):

sbt-bobby: You create a set of rules which outlaw particular versions of a library or plugin, and task Bobby to enforce those rules. If a violation is detected, the whistle is blown, and the build is failed.
Enforcing Consistent Versions of Third Party Dependencies A blog post that describes a way to manage consistent dependencies using an sbt plugin. I think this works if the projects all have the same collection of deps.

CAN Bus

Sat, 25 Jul 2020 20:48:00 +0000

CAN bus: High level introduction

Short for Controller Area Network, a standard designed to allow electronic control units (ECUs) to communicate without a centralised computer. It is a message based protocol.

Mandatory in EU since 2001, us 2008
Runs on 2 wires. CANH (high) CANL (low)
Uses differential signaling (some exceptions)
- When a signal comes in, CAN raises the voltage on one line and drops the other line an equal amount
- Differential sinaling is used in environments that must be fault tolerant to noise
- When a bit is transmitted then signal is simultaneously broadcast to both high and low, the sensors check that they match and if they don’t the packet is discarded as noise
The two twisted pair wires require the bus to be terminated on each end. There is a 120-ohm resistor across both wires on the termination ends
Most vehicles come with the ODB-II connector, aka Diagnostic Link Connector (dlc). It communitcates with the vehicle internal netowrk

(source: https://components101.com/connectors/obd2)

No long term damage. Day 7

Sun, 26 May 2019 20:48:00 +0000

Day 7, last day of a week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

Previous days:

Day 7: Sunday

Last day. Today was much more quiet.

Didn’t generate any rubbish in the morning. For lunch I was binning this:

For lunch we used a full package of sausages. The label on the package showed no recycling notice, so I had to assume they were not recyclable, however they had an Fsc label giving some idea as to the sourcing of materials. Good to know.

Also used the end of a package of butter. It was hard to see if the package was recyclable or not, but thankfully I had a new one, and it is recyclable as seen on the picture below.

I really like spinach, so I am going to have to think about how to source it, what I produce with my plants is not enough, and everywhere I buy them they come in film packaging, which is not recyclable.

Long lived Rubbish for today

Sausage packaging. Not recyclable.
Butter packaging. Recyclable :D.
Spinach container. Non recyclable.

Today’s questions

What are good alternatives for meat wrapping? Are there any secure alternatives?
Are there alternative ways to source spinach and other vegetables that come in film wrapping?

TL;DR

It is good to know about the sourcing of the materials as well as the recycling capabilities. Some packages have Fsc label.

This is the end. There is a summary of the week, you can find it here I will update that when and if I get new answers to the questions posed.

No long term damage. Day 6

Sat, 25 May 2019 20:48:00 +0000

Day 6 of a week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

Previous days:

Day 6: Saturday

A day of doing things outside.

We are not sure on how this will work, could take many hours or we could be back for lunch time.

Turns out it was pretty hot and we were doing active things. There was drinks available with plastic cup disposals. I saw that this was recyclable and I thought about keeping the cup to reserach more, but forgot with everything going on.

For lunch we were at a barbeque I ate a burger with the bun, no rubbish. However, there was another similar plastic cup to the one earlier, and I reused this many times to get a drink, however I binned it as well.

Later we were at a coffee place, I asked for soda water, I thought this might come in a glass, sadly it came with a plastic bottle, this had a Pet symbol

>" Coca Cola intends to use 50% recycled PET in its containers by 2030. While food-grade processing has been established, efforts are being made to improve the efficiency of processing technologies. The availability of post-consumer PET material is also a challenge."

I also found this article from the British Plastic Association an informative read. (now that was a sentence I never thought I would write ;) ) I am not sure what is the impact of these recyclable bottles, recyling them is obviously better than nothing, but how many times can we recycle them? What happens to the bottles that are not recycled? I think caps are not recyclable, what can one do about them? If this week showed me something is that bringing your container for hot and cold drinks has a lot of impact in waste generation.

Later we had a frozen pizza at home. The pizza cardboard is fully recyclable. Sadly the plastic cover is not.

Bottle of sparkling water. Recyclable.
Pizza plastic wrapper. Non recyclable.

Pretty sad.

Long lived Rubbish for today

Plastic cup x 2. Not sure, lets assume they were not recyclable.
Bottle of sparkling water. Recyclable.
Pizza plastic wrapper. Non recyclable.

Today’s questions

How does the Pet process work? There is some information here. Definitely a step in the right direction but given the urgency of the situation with the environment it seems like not enough.

TL;DR

Quite a lot of rubbish for one day. Harder to be on the move and not generate long lived waste.
Plastic bottle recycling is moving in the right direction, but bringing your own drinks container is definitely a big win.

No long term damage. Day 5

Fri, 24 May 2019 20:48:00 +0000

Day 5 of a week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

Previous days:

Day 5: Friday

Working from home again today.

All food an drink consumed today was bought before the start of the week or not by me, so I figured I would document anything I put in the bin.

Lunch time

I had a salad that I prepared myself, I used the last of some nice spicy beetroot. The container was clear plastic which is “widely” recycled, not so for the fork (or at least not mentioned) nor the film covering it. There was a note about how you can bring this to a big store, my nearest one is about 5 miles from here, which I would probably have to drive to, especially If I am buying more food there. I wonder if the home delivery would take this instead.

Later and Questions

I cooked from this evening. There was:

Ham wrapper, I think that is not recyclable.
Oranges net. Also it appears it’s not recyclable
Chips bag. Not recyclable.

Pretty sad.

Long lived Rubbish for today

Ham wrapper, I think that is not recyclable.
Oranges net. Also it appears it’s not recyclable
Chips bag. Not recyclable.
Film and fork from beetroot container.

Today’s questions

Can anything be done about these things that are not recyclable? How could we upcycle them?
I heard (but not researched yet) that there is some rubbish you can bring back to where you bought it and they will deal with it, but I don’t understand if that is true or what does “deal with it” means?

TL;DR

Quite a lot of rubbish for one day.

No long term damage. Aim and progress

Thu, 23 May 2019 20:48:00 +0000

A week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

For previous days:

Gotchas so far

Individually wrapped tea, wrappers are not recyclable, and the tea bags have plastic. Awaiting answers from Veolia.
Severely reduced lunch options. Most of the take away options come in some form of plastic, in the end a hot wrap wrapped in paper from Pret did the trick but at the cost of changing my diet.
I emailed TossedUK about being able to use my own container and they said yes (meaning I need to carry my container with me, which is fine).
It seems my council doesn’t support composting of paper kitchen towels but do allow composting of tea bags (which contain plastic). I emailed them to check.
Taxis and car rides in general, not sure how to calculate the impact from an emissions point of view. If anyone has good links, I am all ears.
Hot drinks seem like a very tricky thing to get whilst being environmentally friendly.
Yay for food you can grow yourself. Even if it is just a small percentage of what we eat.
It is looking like it is really hard to dispose of biscuits wrappers, there is a way to reuse(?) them some how via Terracycle, but I was not able to find out any specifics as to how to do this exactly.
There was a note on a plastic container about how you can bring this to a big store, my nearest one is about 5 miles from here, which I would probably have to drive to, especially If I am buying more food there. I wonder if the home delivery would take this instead.
Can anything be done about these things that are not recyclable? How could we upcycle them?
I heard (but not researched yet) that there is some rubbish you can bring back to where you bought it and they will deal with it, but I don’t understand if that is true or what does “deal with it” means?
How does the Pet process work? There is some information here. Definitely a step in the right direction but given the urgency of the situation with the environment it seems like not enough.
What are good alternatives for meat wrapping? Are there any secure alternatives?
Are there alternative ways to source spinach and other vegetables that come in film wrapping?
It is good to know about the sourcing of the materials as well as the recycling capabilities. Some packages have Fsc label.

All the rubbish in one place

Of the kind we can see:

Awaiting answers from

No long term damage. Day 4

Thu, 23 May 2019 20:48:00 +0000

Day 4 of a week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

Previous days:

Day 4: Thursday

Working from home today. This should be interesting.

All food an drink consumed today was bought before the start of the week or not by me, so I figured I would document anything I put in the bin.

Lunch time

I had a salad that I prepared myself, some of the spinach you see there are from self-grown. There was just compostable waste left behind.

I was feeling peckish later and I had a few biscuits, this resulted in an empty package (no I didn’t eat them all then and there, promise), as I read it I found a reference to Terracycle however when I went to try to use it for the specific brand there was nothing. This is sad, but I ask them on twitter maybe it is just their UX. Update I asked McVities and Terracycle. Lets see what happens

Later and Questions

Food that we already have at home.

Long lived Rubbish for today

A biscuit wrapper.

Today’s questions

What are good options to recycle food wrappers in general and biscuits wrappers concretely?

TL;DR

Yay for food you can grow yourself. Even if it is just a small percentage of what we eat.
It is looking like it is really hard to dispose of biscuits wrappers, there is a way to reuse(?) them some how via Terracycle, but I was not able to find out any specifics as to how to do this exactly.

No long term damage. Day 3

Wed, 22 May 2019 20:48:00 +0000

Day 3 of a week trying to generate the least amount of long lived rubbish by buying renewable or compostable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

For previous days:

Day 1
Day 2

Day 3: Wednesday

Commuting by train, tube, bus and taxi(boo)

It seems like I need to find out about the environmental impact of the taxi ride. I guess this goes in the questions section.

Today’s hot drinks was all leaf tea, no sugar in sachets.

Update Someone mentioned you can request electric taxis (I hailed a cab on the street because I was lost and late) but this is a good idea.

Lunch time:

Had lunch at a place with table service. So no waste here. The napkins were paper and they were not the hard kitchen towel type, so I think I can count that as compostable.

I also had table service for dinner.

Later and other questions

After lunch I ordered a coffee and it came with this chocolate coated coffee bean that was wrapped in plastic so I asked if they could put it back and explained why (I don’t mind if they though I was weird, but I just wanted to make sure they didn’t bin it), so I am not counting that as rubbish for today.

Today I bought a potted plant as a gift, the plant had a plastic container. I will count this as my rubbish. On discussing this with a group they made the point that this plastic has a long life of use, and that since it contains a plant, it carbon offsets itself.

Long lived Rubbish for today

One plant pot.
Taxi ride (approximately 2+ miles, 25 minutes on the vehicles)

Today’s questions

Correct ways to calculate the environmental impact of car rides.
I assume plastic plant pots are not biodegradable, so what is their impact.
How can one calculate the environmental impact of eating out?

TL;DR

Taxis and car rides in general, I need to understand their impact when it comes to polluting the air (I see this as my rubbish too)
Hot drinks seem like a very tricky thing to get whilst being environmentally friendly.

Conclusions from today

Three days into this experiment, the most impactful thing seems to be getting people to about it their everyday rubbish. Many seem interested in improving on this, so when I finish this week I am going to do a summary of the actions that one can take that would reduce the most rubbish, at the same time I think there is nothing like trying it yourself. Also, I am not trying to beat myself up for doing things that I need to do. The experiment was about learning, and see if I can do better, learn, adapt, repeat. If you think doing the experiment would be too hard for you, try to do something you think you can do, or even talking about it helps because it gets people thinking about the rubbish they generate.

Thanks for reading.

No long term damage. Day 2

Tue, 21 May 2019 20:48:00 +0000

Day 2 of a week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

For previous days:

Day 1

Day 2: Tuesday

Commuting by train and tube Today’s hot drinks were either leaf tea or coffee from the coffee machine in the office, no sugar.

Lunch time:

Had lunch at a place with table service, the potential waste there where kitchen towels. I checked a few places and it seems like they are compostable, however I checked the website for my local council and it is not listed in the allowed items. I have emailed them to check What’s the story with that and also to ask what they do with the tea bags, since they allow this as an item to be composted.

Later and other questions

Other members of my household did the shopping this week, since that falls outside of my rules, I am skipping that, but I can see that this would rise many questions. I also notice that since we are in election time, there was some leaflets delivered I wonder how much care was put into the environmental impact of printing and distributing these. And also are them compostable/recyclable.

Long lived Rubbish for today

Nothing!!!! Very happy, tomorrow I am meeting with some friends, so I imagine I will have more constraints than usual.

Today’s questions

What are kitchen towels made of and are they compostable?

TL;DR

it seems my council doesn’t support composting of paper kitchen towels, but I emailed them to check.

Update: The council replied and they forwarded my query to Veolia who are the company doing the composting.

Read about Day 3

No long term damage. Day 1

Mon, 20 May 2019 20:48:00 +0000

Something rather different here. I am doing a little experiment.

A week trying to generate the least amount of long lived rubbish by not buying non renewable things. My rules are:

Focus only on things I buy or consume directly.
From Monday 20/05 till Sunday 26/05 evening.
Document what I do buy and questions that arise from this experiment.

Day 1: Monday

Commuting by train and tube: I have a card that I can top up so no train receipt. but makes me wonder if those train tickets are recyclable or biodegradable.

Hot drinks

I love tea, generally I brew my own leaf tea, however in the office there is tea and I had a cup nearly without thinking. It was a Twinnings Individually Wrapped Tea (no recyclable marking so I have to assume that the wrappers are non recyclable) What are these wrappers made of? I asked them a question on twitter while Iwait, I checked online and it seems that not only the wrapping might not be cool, it seems like the tea bag itself contains plastic source from 2018.

Update: Twinnings replied

Hi Andrea, thanks for getting in touch. Our envelopes are not currently recyclable, however rest assured that the environmental sustainability of our products & our packaging is really important to us & we are working with our suppliers on ways of improving this.
— Twinings Tea (@TwiningsTeaUK) May 21, 2019

By the way, I use the mugs in the office and I don’t generally drink take away tea nor coffee.

Sugar sachets, are they recyclable? biodegradable? I erred on the side of caution and didn’t use sugar.

Lunch time:

I generally prefer salads for lunch. However most salads come in a plastic container :(… Initially I went to a place recommended by a colleague at the office, he mentioned this place was environmentally conscious. On getting there , it had closed down. So I went to Pret A Manger, first I saw a hot wrap, it looked like the packaging was cardboard, but it was not marked as recyclable and when I asked the cashier, he didn’t know if it was ( I was there at lunch time so they were busy), so I got a toasted sandwich, the container was marked as recyclable.

Also, in the spirit of research and learning I emailed TossedUK about being able to use my own container and they replied saying yes :D. I just need to present my container before they start packing it! (A++) Makes you wonder if most places would be OK with this?

Dinner

Dinner was food cooked with item that were already at home, so nothing to report there.

Long lived Rubbish so far

tea wrapper

Conclusion so far

I am pretty happy with how little rubbish I was able to generate just by making my choices based solely on this factor. Another interesting side effect is discussing this with people you chat with during the day. People were keen to help and provide options and ideas. We were all surprised by how much we didn’t know about recycling.

List of Questions

Will update with links if/when I get answers

Is it ok to bring your own container to places that sell lunch to take away? I asked TossedUk and they said yes (maybe other places are cool with it too)?
what is the best thing to do with long lived rubbish (such as my tea wrapper from today)?

Are the following items recyclable or biodegradable:

Train and tube tickets
Tea wrapper
Tea bag
Sugar sachets
Certain types of food packaging

TL;DR

Individually wrapped tea, it looks like the wrappers are not recyclable, and the tea bags have plastic.
Severely reduced lunch options. Most of the take away options come in some form of plastic, in the end a hot wrap wrapped in paper from Pret did the trick but at the cost of changing my diet.
I emailed TossedUK about being able to use my own container and they said yes (meaning I need to carry my container with me, which is fine).

Read about Day 2

Rust, array type not generic over the size of an array type.

Fri, 04 Jan 2019 10:48:00 +0000

Rust

You can declare and initialise a mutable array in Rust like this

let mut xs : [u32; 8] = [1,2,3,4,5,6,7,8];

alternatively you could separate the initialisation like:

let mut xs : [u32; 8] ;
xs = [1,2,3,4,5,6,7,8];

I was surprised when I was not able to re-assign the array with an array of different size… when doing this:

let mut xs : [u32; 8] = [1,2,3,4,5,6,7,8];
xs = [2,4];

you get this error

error[E0308]: mismatched types                                               
  --> src/main.rs:34:10                                                      
   |                                                                         
34 |     xs = [2,4];                                                         
   |          ^^^^^ expected an array with a fixed size of 8 elements, found one with 2 elements
   |                                                                         
   = note: expected type `[u32; 8]`                                          
              found type `[u32; 2]`                                          
                                                                             
error: aborting due to previous error                                        
                                                                             
For more information about this error, try `rustc --explain E0308`. 

error[E0308]: mismatched types

arrays of different sizes are different types. I thought that was really interesting. It is documented

This limitation on the size N exists because Rust does not yet support code that is generic over the size of an array type. [Foo; 3] and [Bar; 3] are instances of same generic type [T; 3], but [Foo; 3] and [Foo; 5] are entirely different types. As a stopgap, trait implementations are statically generated up to size 32. (from source)

(BTW kudos to the Rust people for very nice error messages)

If one really wants to use a set length array you can still do

let mut xs : [u32; 8] = [1,2,3,4,5,6,7,8];
xs[0] = 2;
xs[1] = 4;

Recommended history of computing books

Thu, 04 Oct 2018 10:48:00 +0000

These are some great history of computing books, in this list I chose books that tend to focus on software and programming languages. These are books I like in categories I invented myself.

Reference books

A Science of Operations: Machines, logic and the invention of programming. - Mark Priestley. A book so expensive is sort of an investment, but a good one. If you want to learn about how computing evolved this is the book you need. Great writing style too for a topic that can be a little dry sometimes. Go beyond the pop culture knowledge on the subject and learn about how programming came to be, disentangled from hardware.

Heroes pseudo history

Hackers: Heroes of the computer revolution - Steven Levy. I really enjoyed reading this. It gave me an idea of perhaps what it felt like being at MIT in the early years of computing and being one of the gang. Compared with books like “A Science of Operation” this book feels underwhelmingly light with too many anecdotal stories. The end of the book is rather disappointing.

Horse’s mouth

History of Programming Languages, Volume 2 (ACM Press) by Thomas J. Bergin , Richard G. Gibson . Many of the papers included in this book I read at the edge of my seat. Excellent compilation that includes the papers the presentation of the paper and the discussion that followed the presentation. 100% recommended.

I accidentally a history book

Exercises in programming style - Cristina Videira Lopes. I bought this book for many great reasons (learning about different programming styles) and the surprise was the excellent historical background and further reading contained in it. If you find that history is not your main interest but you want to understand where certain programming styles come from you can do much much worse than this book.

TIL in Purescript

Thu, 26 Apr 2018 10:48:00 +0000

I am learning a little bit of [Purescript] and today I learned:

Custom infix operators (unsuprisingly) don’t work on Psci (the Purescript REPL)

Function application has higher precedence than all other operators ie:

> show $ sumOfSquares 3 4 + 5
"30"

Resources

The Purescript book: Excellent book, not only the content is good, it is a pleasurable read. Will review when I finish it.
Learn x in Y minutes: Purescript Good as a quick reference.
Cheatsheet

Techdebt register

Tue, 27 Mar 2018 10:48:00 +0000

There is really no hard and fast rule for recording technical debt, some people do it on their bug trackers, others in their agile/kanban boards, storing it in a text file with the code is another way. The reason why this can be helpful is because technical debt can be committed with the code, also code can be reviewed with it, giving it extra context. You could simply record this in a file as separete paragraphs, however I have been thinking that standardising the format might help. This template is somewhat inspired by this article, I was compelled to introduce some modifications to it, keeping it small enough to be able to record tech debt fast.

It might be tempting to think that a template is not needed but I digress, without a template:

it can be hard to know what we should record, how much detail is needed.
the technical debt is inconsistent and it can be hard to review stopping often to find the contextual information needed.

Technical debt item

Name: (high level of this tech debt)
Description: (a long form description of the technical debt, can suggest possible solutions if suitable)
Date: (creation of this technical debt record)
Creator: (of this note so that they can answer questions)
Location: (repo & filename or module)
Complexity: (from 1 to 5 how hard would it be to solve the problem NA if you don’t know and want the group to evaluate)
Reward: (from 1 to 5 where 1 is a nice to have and 5 is a significantly measurable improvement both from a performance, security, complexity,etc point of view)

Example:

Name: The module X uses external services in a non-resilient way
Description: module X uses kitt.ie, monkeysjumpingaround.io and boringbutusableapi.com for verification purposes in at least 3 areas of the code, the call to these external services is duplicated and, on failure, at best we log the error (at worst, the system fails silently).
Date: 01/03/2018
Creator: Cat Otterson
Location: X files, Integrations module
Complexity: 3
Reward: 4

Things I wish some told me when I started my computing degree

Tue, 30 Jan 2018 10:48:00 +0000

It has been a long time since I posted anything here.

I recently had the pleasure of giving a talk at Middlesex University, for students at the start of their CS degree. It was a really nice experience.

I was wondering what would be useful things for them to hear and wound up talking to them a little about:

Languages/runtimes: Pascal, Delphi, VB, .net and the JVM.
OO and FP
Tooling and how much it changed over time

and then I mentioned a few things that I think I would have liked to know:

The importance of learning to read code.
The importance of learning to debug code.
Context is what makes a solution good (or bad).
Side projects help you learn a lot.

These are things that sound really obvious in retrospect, I do wonder what it sounded like to them.

Initialization Error on JVM based tests

Wed, 08 Feb 2017 10:48:00 +0000

If you are working with intellij and gradle you might at some point hit the

Initialization error : “java.lang.AssertionError: Java Assertions should be disabled!”

this is because intellij doesn’t import this setting from gradle.

To disable it go to Run -> Edit Configurations… in VM options remove -ea Removing this option means we are not checking for assertions sometimes external libraries use this.

Many shapes and the same function

Thu, 12 Jan 2017 23:13:00 +0000

I was playing around with a small function in Scala and found it kind of interesting that you can express the same thing in different ways. We are writting a function that will fold over a string an accumulate on running parensToFloor a function that looks like:

def parensToFloor(c:Char): Int = ???

The most common way to write this function would be:

def myFn1(s:String) : Int = {
	s.foldLeft(0)((x,y) => x + parensToFloor(y))
}

What would it look like point free?

I arrived to a few options that didn’t work :

def myFnx(s:String) : Int = {
    s foldLeft 0 { _ + parensToFloor(_)}
//>error: Int(0) does not take parameters
//              s foldLeft 0 { _ + parensToFloor(_)}
//                          ^
}

this made sense to me but the following one…mmm I imagine the compiler sees that since foldLeft is curried then it makes sense but what does the compiler want?

def myFnx(s:String) : Int = {
    s foldLeft 0 apply { (x,y) =>_ + parensToFloor(_)}
// >error: missing arguments for method foldLeft in trait IndexedSeqOptimized;
//follow this method with `_' if you want to treat it as a partially applied function
//             s foldLeft 0 apply { (x,y) =>_ + parensToFloor(_)}
//              ^
}

so thinking about that and how to curry, I started trying to add parens around and see what happens and this worked:

    (s foldLeft 0) { _ + parensToFloor(_)}

Something that worked but it wasn’t what I was looking for (it needed a change to the definition of parensToFloor):


def parensToFloor(accumulated:Int, c:Char):Int = ???

//... more stuff.

def myFnx(s:String) : Int = {
// first the non working version same error as before
s foldLeft 0 parensToFloor

// than later evolved to because apply was missing
(s foldLeft 0) { parensToFloor }

then since we are here, might as well go and try and see what it looks like with operators (from a coworker):

(0 /: s) { _ + parensToFloor(_) }

An interesting thing is that the usage of parens and braces is something I still find confusing in time in Scala. The source of my confusion is not totally unfounded, in the docs we can see that:

( ) // Delimit expressions and parameters
{ } // Delimit blocks

however here we see that blocks can also be expressions…

I’ll have to leave this here. More to follow…

VS Code + Ionide-FSharp

Mon, 02 Jan 2017 23:13:00 +0000

For the first post of the year, a short post on something I keep forgetting, hopefully it will help someone else.

With Visual Studio Code, a performant fork of Atom, if you want to use F# then you are probably using Ionide-fsharp extension with Ionide-FAKE and Ionide-Paket. Some aspects of these extensions make this really easy to use for people who are used to the F# environment, but slightly less to the person starting off on F# on a *\nix system for the first time.

Such cheatsheet

Alt+enter to send to F# interactive is a great example of something really useful that if you have used F# on Visual Studio you will definitely try this, but if you haven’t, you probably never will until someone tells you about it.
In Atom and VS Code you can press Command + P (on mac) or Ctrl+P on Windows and it will bring up the Command Palette (you get something like this on Sublime as well) once there enter > and then fsi or FAKE - the > character is the key to this working. I keep forgetting about this because I don’t use vscode often. This is what it should look like:
F12 to go to definition while the cursor is positioned in the code.

Michael Feathers on Types

Wed, 27 Apr 2016 23:13:00 +0000

WHY TYPES AREN’T VERY IMPORTANT , a talk by Michael Feathers

This was a talk at the FP User group. Michael proposed that types are about ergonomics. He proposed that they are not inherently good or bad, but that it depends on the problem and the personal choice, with much more detail that this. It is also quite relevant to keep in mind that Michael has a lot of milage on legacy code bases.

I find that a sane aproach when thinking about types is to think of them in terms of some sort of set of things. Going beyond that makes things difficult to reason about because either

they tend to be things that disagree or slightly overlap with each other
if you think of them in a more specific way and then talk to people that are thinking about them in also a very different but speciifc way, it leads to long winded debates that wind up nowhere (sometimes)

In fact there is a really good post about things that you should know before starting to debate static vs dynamic typing (and it’s a pretty long article :D)

It is not a great idea to talk about types without rebelling agasint it’s definition.

I think I will leave this here,

until the next time

Using Type providers

Sat, 27 Feb 2016 23:13:00 +0000

I wrote a little bit about type providers here but I haven’t in a while and the time has come to check them out again.

The problem

Let’s say that I want to use the Giphy API, which gives back data in json format including a (generally funny) gif. From F# we could take advantage of type providers to avoid a bunch of boiler plate code.

A concrete solution

On an F# script file add a reference to Fsharp.Data nuget package.
In the Giphy website you can find the base url and the key to make a request.
Use the following code:

type GiphyTP = JsonProvider<"http://api.giphy.com/v1/gifs/search?q=monkey+cat&rating=pg-13&api_key=dc6zaTOxFJmzC">
let baseUrl = "http://api.giphy.com/v1/gifs/search"
let key = // Since Giphy might change the key from time to time, go fetch it off their site

let searchGif searchString =
  let searchTerm = String.map(fun c ->  if (c = ' ' )then '+' else c ) searchString
  let query = ["api_key", key; "q", searchTerm]
  let request = Http.RequestString (baseUrl,  query)
  let giphy = GiphyTP.Parse(request)
  giphy.Data
  |> Array.map( fun x -> Uri(x.Images.DownsizedMedium.Url))

One of the results is:

Which is pretty cool, What happened?

The GiphyTP type is a representation of the data available in the sample, if you inspect the type on an editor, you can see what the compiler has infered information about the data. When including a url like I have done here, it will go and fetch a sample. The sample can be a live sample (like in the example above), or a local sample (in one or many file(s) or as a live string).

When calling GiphyTP.Parse(response) is when a new request to the API is made, the types created at the are put to use.
Get data and at this point we could change some of the shape, in this case I return a Uri of one of the possible ones, much more could be done.

If you look at that picture in detail you might wonder, How is it that given a json document, the compiler can give me type information (i.e. Frames, Height are int, Images is a collection, etc), well, that is exactly what the type provider is doing, infering the type at runtime so that you don’t have to. For each element it will try to infer first primitive types and then by combining them , more complex types.

As mentioned in the previous post, the type provider will give you a signature, on demand, as needed by the compiler. At the same time if we decompile that code you will see something like this.

and that is because in the JSon type provider, the types are erased. A type provider does not necessarily contain any types itself; rather, it is a component for generating descriptions of types, methods and their implementations.

Next, let’s see what do type providers look like in other languages.

Resources

Database of programming languages II

Sun, 14 Feb 2016 11:50:00 +0000

I mentioned in a post yesterday that I was looking for a programming languages database with this minimum info:

Programming language name (and family if it has one .i.e. OCaml and the ML family of languages)
When it first appeared (anywhere outside of someone’s mind), and when it was first published (if ever)
Designer and anyone else involved and level of involvement.
some tags (ie paradigm, typed or untyped?, etc)
Influenced by / influenced.

I got some good responses on twitter, thanks to all of you who responded. The one closest was this one from Dmitry Geurkov (@dgeurkov)

Where he links to the visualisation below. Make sure to follow the source as you can click on the nodes to see the influence of any language shown there.

Source: Exploring Data

This link lead to the freebase db. Very close to what I was looking for. I see a need to be able to amplify this information with extra details. Such details should depend on the language.

Scott Wlaschin sent me some great links to this graph from the great book: Concepts, techniques and Models of computer graphics (which has an accompanying MOOC, in case you are interested.)

And this one by O’Reilly Large pdf

Following links from the last site, I found these other very promising links:

Indirectly I also found:

Finally, I found the timeline from the computer history museum.

I was pretty sad to see so many dead links.

Until the next time.

Database of programming languages?

Sat, 13 Feb 2016 19:13:00 +0000

As I try to understand the history of programming languages I am building a time-line with paradigms and families of the programming languages I learn about. I can’t help but wonder why there isn’t (or perhaps maybe I can’t find) some sort of catalog with all this information, it seems like something we could have available, but we don’t.

Something as simple as language name, what other languages influenced it, who worked on it. Anything else that could be useful is a bonus.

Do you know of something like that? The closest I have found is Wikipedia, but that doesn’t give me the data in a way I can play graph it or maybe I need to clean it up. Tiobe index, Open hub and maybe even Rosetta Code might also provide some sort of insight.

I think this can be an interesting project, however I am posting this here in the hope that someone knows about other similar efforts.

These are the iterations of my graph, this is not complete. However it might give you some idea of what I would like for data points given this.

then this (not completed )

I did these by hand because I am trying to iterate fast. It would be pretty amazing to generate these with concrete data. Wow…feels like I was just in a great alternative version of Back to the Future, :D.

So what am I exactly looking for? a database? with at a minimum:

Programming language name
When it first appeared (anywhere outside of someone’s mind)
Designer and anyone else involved and level of involved
some tags (ie paradigm, typed or untyped?, etc)
Influenced by / influenced.

Past and future

Sun, 03 Jan 2016 20:13:00 +0000

This post is a (not so short) summary of the wonderful 1972 paper entitled: “Programming Languages: History and Future” by Jean Sammet[1]. She is not only one of the first (computing science) historians but also a language creator.

The paper is written in a highly enjoyable style and if you are remotely interested in programming, reading it is surely going to reward you. This paper focuses in the historical development of the languages and their interrelations. The key piece in this paper is the chart below where the relationships between programming languages is shown. The graph makes more sense with certain context.

link to bigger version of the graph

Definition of programming language

On the definition of a programming language:

A programming language is considered to be a set of characters and rules for combining them which have the following characteristics:

machine code knowledge is unnecessary
there is good potential for conversion to other computers
there is an instruction explosion (from one to many)
there is a notation which is closer to the original problem than assembly language would be

The scope of the paper is roughly 20 years, going from 1952 to 1972, when, according to the paper there are about 180 programming languages.

Given that this paper context is history, When do you consider a programming languages started? or created? It is something that I encountered as a problem when I was doing some reading on this area and not only dates are not always documented, but also the stage of development at which a defined specification occurs varies, or can be iterated over to become a new version of the language, and in that case, is this the same language or should it be considered a new one?

Why so many languages?

This list is pretty similar to what I would guess today’s historians might come up with:

A really new language concept has been developed and/or a new application area is deemed worthy of having its own language.
After experience with a particular language, its deficiencies are clear enough that a complete new language is needed and justifiably created to correct them.
Facilities of several languages are best combined into a single new language
It is felt to be easier to get additional capability or changes in style with a new language rather than to extend or modify an existing one.
It is fun to design and implement a new language, and someone wants to do it and can obtain the funds.
There are personal preferences and prejudices against the existing languages even though one of these languages might serve the purpose for which the new language is intended.
The developer is unaware of the existence of a language that meets his needs, so he creates his own while believing he is meeting the conditions of (1) or (2).

I wish 2 would happen more often. Can’t think of an example for 3, anyone? Perhaps 5 would be different because I think funds are not really necessary but probably a good idea, I am thinking of Elixir, Elm as great examples of projects that started.

Reasons for the importance of a language

This section has the most memorable quotes (stuff that is still sadly true, 4 decades later):

For example, the psychological issue of snob appeal is more important than many people might think. Thus, the personal prestige and leadership (or lack thereof) of those individuals who are involved in the development of a language play an enormous role.

…

The best example of languages which inspire some people are ALGOL and APE\360; on the other hand neither BASIC (at the small end) nor PL/I (at the large end) generate as much personal enthusiastm

Major Languages (at the time)

This is my favourite section of the paper. The languages below have been chosen because of their relevance as well as their uniqueness (except Cobol), they also apear to have been developed independently of each other.

APT. The first language for a specialized application area.
FORTRAN. The first higher level language to be widely used. It opened the door to practical usage of computers by large numbers of scientific and engineering personnel.
FLOWMATIC. The first language suitable for business data processing and the first to have heavy emphasis on an “English-like” syntax.
IPL-V. The first–and also a major–language for doing list processing.
COMIT. The first realistic string handling and pattern matching language; most of its features appear (although with different syntax) in any other language attempting to do any string manipulation.
COBOL. One of the most widely used languages on an absolute basis, and the most widely used for business applications. Technical attributes include real attempts at an English-like syntax and at machine independence.
ALGOL 60. Introduced many specific features in an elegant fashion, and combined with its formal syntactic definition, inspired most of the theoretical work in programming languages and much of the work on implementation techniques. More widely used in Europe than in the United States.
LISP. Introduced concepts of functional programming combined with facility for doing list processing. Used by many of the people working in the field of artificial intelligence.
JOVIAL. The first language to include adequate capability for handling scientific computations, input/output, logical manipulation of information, and data storage and handling. Most JOVIAL compilers were written in JOVIAL.
GPSS. The first language which made simulation a practical tool for most people.
JOSS. The first interactive language; it spawned a number of dialects which collectively helped to make time-sharing practical for computational problems.
FORMAC. The first language to be used fairly widely on a practical basis for mathematical problems needing formula manipulation.
APL\360. Provided many higher level operators, which permitted extremely short algorithms and caused new ways of looking at some problems.

Important eras

These are highlights of important periods and events associated (genreally happening in the form of a conference)

Earliest(1952-1956) The beginnings of understanding of concepts. The terms pseudo-code, automatic coding,automatic programming, compiler, and interpreter were common.
Milestone Meeting (1956). First meeting to talk about high level programming languages, so what we are calling programming languages in the context of this paper
Most prolific years (1958-1959). The following events all occurred during that period: (I am just listing the ones I found more relevant)
1. The development and publishing of the IgL (International Algebraic Language) report, which became known as ALGOL 58.
2. The development of three languages based on the IgL specifications.
3. The presentation to the 1959 UNESCO meeting of J. Backus’ formalism for describing ALGOL. This was the foundation for much of the theoretical work done in programming languages since then.
4. The formation in May 1959 of the CODASYL Short Range Committee (later renamed the COBOL committee) and the completion of the specifications by December 1959 (although they were not published until 1960).
5. The start of work on the development of LISP in 1959.
1960-1970. Maturation of the field. Perhaps one of the most important practical developments, although scorned by many theoreticians, was the development of official standards for FORTRAN and COBOL, and the start of standardization for PL/1.

Key concepts

In this section, Sammet highlights some concepts.

Starts of with the Backus Normal Form, introduced by John Backus (since it is so relevant to the history of PLs I guess the mention tried to highlight the historical impotance).

The significance of a formal syntactic notation is threefold:

It provides a rigorous way of defining the syntax of a language and eliminating the annoying ambiguities of sentences such as “a name contains six characters and both the first and last character cannot be a hyphen.”
It provides the link between the practical concerns in the programming language field and the theoretical work done by linguists, most notably N. Chomsky. This permits application of linguistic concepts and techniques to programming languages. Although BNF was developed independently by Backus, it is really one of Chomsky’s grammars with a different notation.
It led to the development of syntax directed compilers, which in turn gave rise to a more theoretical study of compilation techniques and the possibility of a “production line approach” to developing new compilers.

There is also mention of the formal semantic definitional techniques, where McCarthy and IBM Vienna Laboratory are key contributors. IBM Vienna created the formal definition for PL/1

The monumental size of the formal definition of PL/I precludes it from .being of current practical use. However, it is a major conceptual part of a currently unsolved problem in all of programming which is how to determine whether a program does what we want it to do.

Then The attempt at designing computers whose instruction code is a higher level language, significant concept, not yet achieved (I have to admit I don’t know anything about this, feedback or related links most welcome)

Finally , there is User defined languages have been an area of interest for many years. Is this what we call DSLs these days? ( I’ll need to read up on the references), it kind of sounds like it, tho they talk about directly giving access to users.

Current status (as of 1972)

This is really interesting, at the time these were the interesting topics:

Extensible languages
Proving correctness of a programs
Use of higher language programming for systems programming

Cool stuff particularly when you think about the research that became into being around that time with type systems.

The future

The rest of the paper goes of to talk about what seems to be the future. Most predictions have more or less become real.

The user could use his native language, including notation (e.g. algebra, molecular diagrams) appropriate to his particular field. This concept does not envision one single computer system understanding all of English. It does envision many systems, each of which is capable of dealing with a particular field…

the next best thing will be user defined languages. By this we mean (software) systems which permit users, first, to define languages that fit their own needs with respect to functional capability,jargon, and personal tastes in style

While the day of asking the computer to “COMPUTE THE PAYROLL FOR MY COMPANY” is at least one or two decades in the future, I believe we will see a large decrease in the amount of detail a user must provide.

…

The use of current languages is not likely to change drastically for many years. It seems likely that FORTRAN and COBOL will be with us for at least five and probably ten more years.

ALOOL 68 will … namely inspire another round of development of implementation techniques and devotion to elegance in language with less concern for the practical world. It seems virtually certain that ALGOL 68 will not become widely used in the United States, and probably not elsewhere.

Computers are now becoming common… To determine the real effect–both direct and subliminal–of this education on the next generation requires a better crystal ball than this author possesses…people will grow up recognizing the computer as a tool for everyone, just as the automobile, the telephone, and the stove

Wow…feels like I was just in a great alternative version of Back to the Future, :D.

[1] Sammet, Jean E. “Programming languages: History and future.” Communications of the ACM 15.7 (1972): 601-610. Download

More Computation expressions

Sun, 06 Dec 2015 20:13:00 +0000

I guess I am one of those people that really enjoy this time of the year, so I had to add another post. This is a sneaky(?) second post for #FsAdvent. Ready for some more computation expressions?

In the previous post I introduced a definition and parts of a computation expression, as well as one of the simplest example.

The beauty of reality

I started looking at computation expressions because I was trying to deal with the “C#-F# design mismatch”(™) (yes I just made ~~discovered~~ that up) meaning that I wanted to deal in some nice ways with the fact that when I am using a C# object it will occasionally be null and other fun things. And when I started reading about solutions to that, I found that there are some well known ways to deal with that.

Sometimes the world surprises you with something amazing, could be a moon rising in the night sky, or maybe someone having a nice gesture towards another fellow human just because. Perhaps there is something to this natural ordered chaos. And with ordered chaos in mind, a great example of usage of computation expressions is error handling.

So, lets see some code

    type MaybeBuilder() =         
        member __.Bind(maybeValue, func) =
            match maybeValue with
            | Some value -> func value
            | None -> None        
        member __.Return value = Some value

    let divide a b =
        match b with
        | 0 -> None
        | _ -> Some(a / b)

    let maybe = MaybeBuilder()

    let divisionM a b c d =
        maybe { let! x = divide a b
                let! y = divide x c
                let! z = divide y d
                return z }

Similar to the example in the previous post, we have a builder, in this case, MaybeBuilder and the signature for this function is :

Bind:: ‘a option * (‘a -> ‘b option) -> ‘b option

Bind takes a wrapped value (‘a option) and a function that takes an 'a and returns a wrapped 'b (‘b option) and returns a wrapped 'b(‘b option). In F#, 'a option is a generic option where ‘a can be any type. You can use most generic types as wrappers.

A great explanation on why Bind signature is relevant comes from this post. Go ahead and read it. I’ll just pretend you didn’t read it try to explain it and then you will think that it might be good to go and read it :D

What happens in Bind if maybeValue has a value

Unwrap ‘a , execute the function
Return a wrapped value (of type ‘b option)

What happens in Bind if maybeValue is nothing

There is None so we do nothing.
Return a None (which is still of type ‘b option )

The good thing is, because we return with signature 'b option that means we can feed the result back into Bind if that is necessary.

This triple of a wrapped type, Bind and Return is called a monad, and that is cool because when you realise something is a monad, then that means you get some other stuff for free. To show you how, I’ll start talking about Monoids.

Monoids

I am sure you have heard that

A monad is a monoid in the category of endofunctors.

When I read that first I have to admit that was not terribly useful. So I went to check out Monoid, and it turns out they are pretty cool :D

A monoid needs a type and an operation and it needs to follow the following rules:

Closure. The operation must have the following signature ‘a -> ‘a -> ‘a
identity. There must exist an instance I of ‘a such that ‘a . I = ‘a
Associativity. Given the same order, no matter how we associate the operations so (a . b). c = a .( b. c ) where a, b and c are instances of ‘a

examples For The Win!!

lets say we have a type Colour and an operation addColour

    type Colour =
        { r : byte
          g : byte
          b : byte
          a : byte }

    let addColour c1 c2 =
        { r = c1.r + c2.r
          g = c1.g + c2.g
          b = c1.b + c2.b
          a = c1.a + c2.a }

Does this constitute a monoid?

Closure: the function addColour has the signature: val addColour : c1:Colour -> c2:Colour -> Colour It looks like we do have closure.
Identity. There exist a colour, black, that if you add to any other colour, the result is the same colour.

      let neutral = { r = 0uy; g = 0uy; b = 0uy; a = 0uy }
      let someColour = {r=44uy; g=21uy;b=99uy;a=255uy};;
      do someColour = (addColour neutral someColour) |> printfn "Should be true: %A"
      // This test covers just one case, we will deal with that shortly

It looks like we have an identity

Associativity. We can add three different colours and no matter which two we add in which order, the result is the same colour.

    let ``The operation is commutative`` (a : Colour, b : Colour, c : Colour) =
      addColour a  (addColour b  c) = ( addColour (addColour a b)  c)

    Check.Quick ``The operation is commutative``

When we run that the result is:

` Ok, passed 100 tests. val it : unit = ()`

What happened here is that we randomly generated a, b and c to be 3 colours and we ran that test a hundred times. Verifying that in fact this pair is a monoid.

Knowing that something is a monoid can be really useful because you have certain properties that are true of monoids, for example:

You can convert pair-wise operations to operations that apply to collections
You can parallelise operations
Incrementalism

For more details on monoids, please read this post.

The obvious next step now is to create monoids with computation expressions, and this is very cool because to implement them we need some of the other functions that we can use in a builder.

type MonoidBuilder ()=
  member this.Zero() = neutral

  member this.Combine(x, y) = addColour x y

  member x.For(sequence, body) =
      let combine a b = x.Combine(a, body b)
      let Z = x.Zero()
      Seq.fold combine Z sequence

  member x.Yield (a) = a

let monoid = new MonoidBuilder()

let monoidAdd xs= monoid {
     for x in xs do
       yield x
     }

In here we are using some new members: Zero, Yield, Combine and For. Below are all the functions that can be used on builders,

(source)

Custom Operations

      type SimpleSequenceBuilder() =
          member __.For (source : seq<'a>, body : 'a -> seq<'b>) =
                 seq { for v in source do yield! body v }
          member __.Yield (item:'a) : seq<'a> = seq { yield item }
          [<CustomOperation("where")>]
          member __.Where (source : seq<'a>, f: 'a -> bool) : seq<'a> = Seq.filter f source        

      let myseq = SimpleSequenceBuilder()

and you can call this

    myseq {
        for i in 1 .. 10 do
        where (fun x -> x > 5)
        }

this translates to:

    let b = myseq
    b.Where(
      b.For([1..10], fun i ->
        b.Yield (i)),
      fun x -> x > 5)

I guess by now we are all a bit tired like these otters:

See you next time

Batmandrea

References

Functors, Applicatives, And Monads In Pictures
Computation expression wikibooks
Computation Expressions (F#) msdn
Some Details on F# Computation Expressions - D Syme 2007
The computation expression series - F# for fun and profit
Why Do Monads Matter?
Where is the monad A post on FParsec about why they moved away from a monadic aproach due to performance
The Road to Functional Programming in F# – From Imperative to Computation Expressions
FSharpx.Extras (github repo)
The marvels of monads - Wes Dyer

Computation expressions and microphones

Sun, 06 Dec 2015 19:13:00 +0000

It is that time of the year, and #FsAdvent is now an event we all look forward during the happy season :D. My contribution to it is this write up about computation expressions.

Why?

I guess it is kind of hard to learn something if you don’t know what to use it for.

Some well known usages of computation expressions are asynchronous programming or creating DSLs. They allow you to determine the semantics of your code, in short, you can decide how your code gets executed.

Having a computation do some of the heavy lifting behind the scenes can dramatically reduce redundant code.

You were saying about practice?

Below is an example of a computation expression builder. Which is a “normal” F# type that has some methods that the F# compiler will look for. The compiler recognizes a builder because it has certain functions with well defined names (such as Bind, Return, For, etc), more on this later.


      type SimplestBuilder () =
        member this.Bind(x,f) = f x          
        member this.Return(x) = x

The SimplestBuilder type is a computation expression builder. “A builder is a record of operations that defines the semantics but also the syntax available in the block.” [Petricek, Syme (2014)]. In this case we are just saying that when Bind runs it will just call the function f with the parameter x. And when we call Return the function result will be the parameter passed into the function. The question here is how do they get called?, we answer this as follows:

      let simple = new SimplestBuilder()

      let x =simple{
              let! one = "One"
              let! two = "Two"
              let! testing = one + two
              return testing}

When we see the definitions for Bind and Return those methods mandate how let! and return behave in the lines above (in this second code sample). We can say that the computation expression is everything after let x = declaration.

The result of running the code sample is the following:

  >val x : string = "OneTwo"

It might be worth remembering other computation expressions you might be already familiar with, such as.

Async workflows

(workflow is a common alternative name for some computation expressions)

      let extractLinks url =
          async {
              let webClient = new System.Net.WebClient()

              printfn "Downloading %s" url
              let html = webClient.DownloadString(url : string)
              printfn "Got %i bytes" html.Length

              let matches = System.Text.RegularExpressions.Regex.Matches(html, @"http://\S+")
              printfn "Got %i links" matches.Count

              return url, matches.Count
          };;

[Example from wikibooks]

MBrace

    let remoteResult =
        cloud { printfn "hello, world" ; return Environment.MachineName }
        |> cluster.Run

[Example from MBrace.io]

In both examples the builder is defined elsewhere, and as consumers of the computation we have a set of things we can do. When we don’t use the workflow with the expected syntax, (generally) the compiler will warn us with errors like:

This control construct may only be used if the computation expression builder defines a ‘ReturnFrom’ method.

The builder works by using the compiler to convert the syntax into a block like this, for the SimplestBuilder we saw at the very start of this post:

    let y =
      simple.Bind("One", fun one ->
        simple.Bind("Two", fun two ->
          simple.Bind(one + two, fun testing ->
            simple.Return(testing))))

This de-sugared syntax (syntax-max if you will :) ) is harder to write and also harder to read.

So this post tells us a little bit about what computation expressions are and how you can create very simple versions of them. In the next post we will see how to use them with a little more context.

Thanks for reading and happy holidays!!

Yours Batmandrea

Reading about primes, type providers and more

Wed, 28 Oct 2015 19:13:00 +0000

Some stuff I have been looking at today that you might find interesting

Having fun with type level numbers by using a type provider Excellent post that I have been meaning to read about implementing a type provider for primer numbers, complete with the explanation on primes and type provider implementation. Really the making illegal states unrepresentable .
Nested looping to programmatic depth in F# This post comes to a solution to the lack of break and return in F## by solving the similar problem we did in a recent Functional Kats meetup The first time I thought when I saw the problem was, oh this is about Computation expressions but although there is a link to a solution by Tomas Petricek that uses them this post shows a different approach that shows better performance 66ms versus 880ms.
Eve project you might agree with they ideas behind it or not, but it is worth checking out this project about trying to help us think, while also changing the way we write code. Eve: Better tools for thought http://witheve.com

Yours BatmAndrea

FSharp Gotham - Experience report

Sun, 18 Oct 2015 19:13:00 +0000

F# Gotham stared on the morning of the 16th of October at Jet’s Offices (lovely views of the city)

I saw the very start of Riccardo Terrel’s tutorial on Reactive and Concurrent F#. He was covering the practical aspects of writing safe concurrent programs, and how to do that with functional programming languages, in particular F# . Sadly I was rehearsing my talk. From the distance it looked fun.

Then it was my turn, I talked about Computation Expressions, the idea of this talk is to introduce them, trying to demistify them a little bit with the help of awesome pictures of otters :D We covered some well known CEs such as async, error handling monads as well as mbrace.

There is an extensive list of resources at the end of the slides for my Computation Expressions in Context .

Then it was time for two people from Microsoft to answer some questions. David Stevens, the new Programme Manager for F#, started this talk with a brief history of the language and some features of the language he particularly liked, and some extra information trying to give people some context of where he was coming from. Great presentation. This was followed by some questions from the audience, Jay Schmelzer, one of the directors from DevDiv, joined David. The questions varied from feature parity to marketing support, azure, the collaboration with the F# Software Foundation and more. I think we got some very honest as well as some promising answers. I am looking forward to see how it all goes and the near and distant future. I believe all sessions have been recorded and will link it here as soon as they becomes available.

[Update 21-10-2015] There is an article on InfoQ with more details about this talk.

Next it was lunch time and time to mingle. Great food. Kudos to the organisation team and the sponsors, for putting on a great event.

Then it was time to listen to Charles Petzold talk about Using F# for Xamarin forms. He started off talking about his early career as a Programmer using Fortran and APL amongst other languages. Then he built a series of samples targeting multiple devices using Xamarin Forms with F#. He showed:

How to setup the solution so you can use F# (it might be a idea to create a template for this type of solution)
Deployment to many devices.
A Sieve of Eratosthenes in 3 or 4 lines of code (yay!)
Converting the code to work asynchronously

and more. Nicely presented. I wish I could find a way to contact him to let him know about Paket, I think he might appreciate it.

Then it was time for the optimization panel with Jon Harrop, Jack Pappas, and Lev Gorodinski. MCed by Paulmichael Blasucci. This was a highly interactive session where we heard about collections and data structures (how they always turn up on these type of conversations…. :D) common things to avoid and some very funny war stories. One of the questions was about a particular post Jon Harrop had posted a few years ago doing a language comparision, and how that evolved and how it compared to now. There was also some discussion on tooling where the usual ones turned up VS interated one , Concurrency visualization, roll your own, and also one I heard of but never used, Perf View. I was kind of suprised no one mentioned dotTrace and dotMemory.

Finally Phil Trelford closed the conference with a talk that I am lucky to have seen multiple times, his “Write your own compiler in 24 hour” talk. It is funny how you always pick up new things when you watch something a couple of times. This time I was looking at how focused on the process of writing the compiler, starting with the parser and testing out his design before moving off to implementing the AST. This made me think about something else we were discussing on a “hallway session” about how do we make decisions when you have limited knowledge, my take on it is you choose a path and try to do a very small implementation trying to fail fast, as fast as possible, focusing on how is it failing , iterating and then implementing a solution you know does what it should do.

Another thing that was really cool about this conference was the one track and highly relaxed feeling around it (lots of space, comfortable sitting).

Since I was wearing a cape that was given to all of us as swag, someone called me BatmAndrea, I think I’ll keep this :)

Yours BatmAndrea

Functional Katas Review Of Kata

Thu, 15 Oct 2015 00:00:00 +0000

Functional Kats: Kata review

{highlight FSharp}

let isPrime x =
    match x with
    | 2 | 3 -> true
    | x when x % 2 = 0 -> false
    | _ ->
        let rec superPrimeCheck i =
            match i with
            | i when x % i = 0 -> false
            | i when x < i*i -> true
            | _ -> superPrimeCheck (i + 2)
        superPrimeCheck 3

isPrime 1
let oneM = 1000000
let checkStuff maxNumber =
            [2..10000]
            |> Seq.ofList
            |> Seq.filter(fun x-> isPrime x)
            |> Seq.fold(fun acc x ->                                                                                    
                            if (isPrime acc && acc <= maxNumber)then
                                printfn "found %A" acc
                            acc + x                            
                            ) 0
{endhighlight }

Choose sequences because:.

A seq<'a> computes on demand, so even tho we are not doing this here, maybe that can be a possible way to optimise this code?
Side effects happen when the value is consumed
the yield of a sequence expression can also be another sequence, signified through the use of the yield! keyword

Quietness

Tue, 28 Jul 2015 19:13:00 +0000

Lately I have been working on the port for our game Onikira: Demon Killer (very very close to release by the way)… it is a lot of work but hopefully good stuff for everyone will come out of that, namely the port of the Duality Game engine and all dependencies to Android… if you want to read a little about the chaos of that, you can read the Port Notes (please note, it might make no sense, these are notes that might only make sense to me, if even…). The way we are going about this is to try to get all the parts working in the fastest possible way (so we can release the game on the new platform) and then come back, and do the cleaning thing and collaborate with Adam, the main maintainer for the Duality Game Engine to create a nice, clean version of the port . This is the reason why all the changes for this port are forks, all of them available on github repo

By the way you can see all open source builds available via our TeamCity build server.
A very by Thank you!! to Hadi Hariri and JetBrains for the Open Source license for Teamcity :D (we love it). Also much thanks to Xamarin and Dean Ellis, of Monogame fame, for the Open source license too :D

If you have any questions about the port or want to help on the open source effort for it please let me know. Twitter might be the best way.

Also I have to apologize to people trying to use the Duality Scripting plugin as it is not very user friendly at the moment, but I do want to spend sometime as soon as this game ships.

Which reminds me, Come to Kats Conf 15!!!, a functional programming conference in Dublin on September the 12th, if you are in Dublin or close you should consider attending.

Computation expressions at NDC

Wed, 17 Jun 2015 19:13:00 +0000

Yesterday at NDC Oslo I presented a talk about computation expressions, you can find the slides here

Computation expression in context : a history of the otter king - Andrea Magnorsky from NDC Conferences on Vimeo.

I started a little fp-track NDC Oslo album, https://vimeo.com/album/3452190 (I will add them as they come)

All of the code shown during the talk (plus some handy extras) can be found here

These are some of the resources used to create this talk, in no particular order

Abstraction, intuition, and the “monad tutorial fallacy”
The “What are monads?” fallacy
Beyond Foundations of F# - Workflows
Monads, Arrows and idioms there is a bunch of papers here.
Why a monad is like a writing desk Video
Understanding Monoids F# for fun and profit series on monoids
Understanding Monoids using F# From gettingsharp-er :)
Syntax Matters: Writing abstract computations in F# paper by Tomas Petricek and Don Syme about computation expressions
Monads explained from a maths point of view Video
Comprehending Monads P.Wadler paper
Monads for functional programming P.Wadler paper
F# language specification
Try Joinads F# research extension for concurrent, parallel and asynchronous programming.
Functors Applicatives and monads in pictures
F# for fun and profit - Computation expressions series
Monads for the curious programmer

Once there is a video I will also add the link here

Thanks

Porting an engine to Android 1

Wed, 13 May 2015 13:13:00 +0000

As you might or might not know to make Onikira: Demon Killer we use an engine called Duality and a few weeks ago we started to port it to android.

Starting out

As we started we made a list of things that we needed to look at

Shaders
- GLSL
  - All shaders need to be update to min #version 300
  - Fixed function methods like ftransform need to be removed and replaced with manual multiplication of transformation matrices
  - Shader in and out variables need to be defined for passing data from the app through the vertex shaders and into the fragment shaders
- Engine
  - the engine should by default pass a bunch of predefined variables to each shader
  - predefined variables should be defined for common things like modelViewProj
  - the Shader class should try and pass all common variables to the contained shader at bind time
  - the engine needs to have a central place where common variables live that can be written to by the draw device when variables change (BeginRendering most likely) and read from by the shader classes.
Rendering
- cUrrently uses fixed function vertex attribute bindings in the Vertex* classes. These need to be updated to use generic vertex attributes.
Windowing
- need to specify the min GL version when creating the GameWindow class (DualityLauncher)

These were a conversation starter.

First steps

OpenTK

The first thing we did was to try to get OpenTk running. Here the awesome Dean Ellis gave us a huge hand by talking to us and then pushing some code to the repo.

Duality uses a fork of OpenTK, so to port it we forked too here.

add openTk.Android project
add a sample project to know everything is working
…

Farseer

Duality depends on Farseer so we also had to fork this project. The process so far has been super simple // more details

Duality

Explain changes to the branch here

Progress

…. add more day by day (I have something like this already)

12th May

Today we finally got a texture rendering and using OpenGL 4.4 via OpenTK. We also decided that all the repositories will have their master untouched (as it was from any original fork) and that all android related changes will go into the branch ‘android-port’

13th May

Today we are working on other default shaders rendering and input.

15th May

–

Summary

We are porting Duality runtime to Android, all the code is available on this user on the respective android-port branch of each repository. If you are interested in this and want to help or have questions, let us know.

Lambda Days and dev At Lodz

Sun, 01 Mar 2015 23:13:00 +0000

I spent part of the past week in Poland, I landed in Łódź (if you are not a Polish speaker, look up the pronunciation). Totally extreme friendliness. I felt right at home, maybe there is something to do with my last name :D. Thanks so much for your superb welcome, and once again thanks to Kuba for driving from Lodz to Krakow (I owe you a drink).

I think Poland is a great country, I have a lot of respect for countries that take their pastries seriously and with high availability.

dev@Łódź

I was really curious about how a group that is about programming cross domain, cross platform, basically anything goes would work. I was pleasantly welcome by a highly engaged and fun audience. Kudos to you!

I am still not sure how to report on my own talks :D. Suggestions welcome.

After my talk there was another talk about Romantic Web:Relation Object Mapping for semANTIC WEB in .net. Certainly a catchy name :). The claim is that “RomanticWeb is the world’s first ORM class solution for graph-based data written fully in C# that allows developers to work with the RDF data in a way the would work with any other data in an object oriented manner. This can be achieved by creating data models that can then be mapped to RDF statements in a fully transparent way” it looked interesting tho a bit heavy on boilerplate, I am still not clear where would you use something like this, but, as always is cool to see things you don’t know about.

Lambda Days

The day started with a talk by Garreth Smith. In his talk he described how he has been trying to rediscover the joy of coding through some experiences with his son using Scratch. The talk was very entertaining, and there was a few hints of something to take away, I think he was trying to encourage us and himself to be a little more open about what it means when someone tells you something feels good (from a programming point of view) and how we can learn from that (or something). I think he was on to something but didn’t drive it all the way home, though topic. I really hope we get more iterations on this. He recommended The timeless way of building and it looks interesting enough to pick up.

I had some hallway sessions and then I went to Rafał Studnicki’s talk on running Erlang on 32k of Ram. It turns out you can run. This was a talk in a series of 15~20 min talks about research papers. Interesting format.

After lunch, it was Evelina Gabasova’s turn to talk, she had a quite large room-full of people. The talk went over a comparison of other tools used for research in cancer and how she uses F# and the type providers to do better Science. One bit of info I didn’t know about, men can also get breast cancer.

After that I went to “A year of Haskell” by Justin , this was a cool talk, if someone can go and set up a start up in Ecuador that does Haskell and it’s working out, well this is pretty inspiring. :D He mentioned the pain of supporting ageing Rails projects and how he found Haskell a good alternative. A not precise quote:”Haskell is easier to learn than Ruby”. The tone of my comments here leave out how he is really not trying to force this on you but rather, he is talking through his own experience. This is what is like when you get to an existing Ruby project

Then it was my turn to give a talk. My slides are here thankfully I have no pictures.

In the party, there was pizza and beer and a lot of talk about types. At some point Edwin Brady said something around the lines of “I would write a php backend for Idris” (there is a story behind the beer tokens you see in the pics), this was immediately twitted by Alvaro Videla a few days later Edwin sent this tweet around:

Can I have a Turing Award now please? Or does this rule me out for life? https://t.co/ByV8hpl7fM @old_sound & @silverSpoon did pay up front
— Edwin Brady (@edwinbrady) March 3, 2015

Day 2 of Lambda days started with a talk by Kinga Panasiewicz, a neuroscientist. She did a super interesting talk about how our brains work, I would like to see more like it. In the talk she mentioned the effects of too much light before sleeping time, how poor our memory is and other things that I can’t remember (maybe because I am trying to remember more than 7 things?).

Scala, Akka, Play: The Why and How of reactive web-applications on the JVM by Manuel Bernhardt, admittedly Scala is not something I know much about at the moment, but I thought it would be good to learn a little bit more about it. On this talk Manuel went over the basics of Scala, Akka and Play super fast and went on to explain how they work together. One of the gems of this talk was when Manuel showed how Mailbox works with an example from Star Wars please skip for spoilers.

After that I went to a talk called Implementing graph representation model for parallel and distributed systems using Erlang, this talk was a little confusing, there were many definitions at the start and then a bunch of graphs, the graphs showed some sort of really good performance metric, but I really couldn’t understand much of it, I am going to put it to lack of sufficient tea, too early :D. I am also sorry I forgot that at the same time Tomasz Jaskula was giving a talk about F# that got really good comments.

After that I went to Alvaro Videla’s excellent talk about RabbitMQ, he had a live simulation of how things worked that I really enjoyed. He talked about the internals of RabbitMQ and the result of that is that I am more and more curious about Erlang; I wish the recording of it was online already.

After that I went to a talk by Michał Łusiak his talk started super well because his first slide was a picture of a bridge in Dublin, and he was talking about type providers, something I have been interested of late the talk was pretty cool as he went on showing many existing type providers and their use cases, including the ones that seem rather useless but are fun (like squirrelify) :)

Finally Tomas Petriceck had a cool talk on literate programming, he was talking about the origin of literate programming from Knuth and trying to rescue the feel of it and bring it into F#. He was missing some graphs so he created a DSL for making them and he said he would make it available, which he did slides and code a few days after the talk (and prompt me to finish this post). As always there was another talk I wanted to attend to too but sadly you can only be in one place at a time.

After the conference a good few of us went for dinner, Lambda Days and Krakow was super fun :) Big kudos to the organizers and everyone involved in making it happen.

Type providers

Sun, 22 Feb 2015 19:44:00 +0000

The awesome Rachel and myself were on Mostly Erlang podcast the other day (it’s not live yet), check it out they have some very cool episodes.

Anyway I was there and we were talking about Type providers and I said something around the lines of “type providers generate erased types…” blah. This is not correct so this post is an attempt to cure that mistake. (I could tell you how I woke up at 5am the next morning and realised I said something wrong and someone was there to record it but, don’t worry I won’t).

Anyway, what is a type provider?

I was at a talk somewhere a year+ ago. All I remember is that 3 lines of code gave me access to typed info from a source (in that case a csv) without any further setup, I though Wow, all that wasted time!, No more!! I was thinking of all the mapping I had done with ORMs or using something like FileHelpers + setup (that would need to be changed if the data changed even a little bit).

so like 5 seconds later we were all thinking … how does it work?

According to msdn: “A type provider is a component that provides types, properties and methods” thanks Sherlock :D I hope it got better but I got bored … so I moved on to other sources.

Like this paper: Strongly-Typed Language Support for InternetScale Information Sources, and that has better info,

“A type provider is a compile-time component that […] provides two things to the host compiler/tooling:

A provided component signature,… that is computed >on-demand as needed by the compiler

A provided component implementation of the component signature. This is given by either an actual .NET assembly that implements the component signature (the generative model for the provided types), or, a pair of erasure functions giving representation types and representation expressions for the provided types and provided methods respectively (the erasure model for the provided types).

[…]Essentially, a type provider is an adapter component that reads schematized data and services and transforms them into types in the target programming language. […]

A type provider does not necessarily contain any types itself; rather, it is a component for generating descriptions of types, methods and their implementations. A type provider is thus a form of compile-time meta-programming, a compiler plugin with access to the external world that augments the set of types that are known to the type-checker and compiler.”

I found this significantly more informative. I hope you too :) One thing to note here (I made it bold and all) is the “on demand” meaning that (steals again from the paper) “the provided type space can be very large or even infinite.”

The other thing I found interesting is that you can implement a component by generation or erasure. The erasure bit , as far as I understand, is that the type looks like a normal type at compile time, but during runtime it’s erased to a common type. So there is less overhead.

I am sure you have seen examples of usage of type providers, I particularly like the csv one

  [<Literal>]
  let path = "..\IrelandProgrammingLanguages.csv"  
  type Languages = CsvProvider<path>
  let data = Languages.Load(new FileStream(path, FileMode.Open))
  let languageCount = Seq.toList data.Rows
                        |> List.map ( fun r -> splitAndCount r.``What programming language(s) are you using in production?``)

The first line is just a path, in the second line we create a type using the CsvType provider passing the path as a parameter. To load the data from the csv we call Load. Finally the last line is actually using the data provided, where one of the column names on the csv file is What programming language(s) are you using in production? .

If you are into type providers, you need to know Ross McSquirrel(I might have made up a better last name for him), check out his talk about Ridiculous type providers (again I might have given the talk a new and hopefully better name :D).

I was going to write about creating type providers, but this 2 part post by Michael Newton beat me to it (by about a year) :D and it’s worth checking it out to understand how this cool language feature works.

Creating a vm for Haskell development

Thu, 19 Feb 2015 11:44:00 +0000

It has been a while since I used any flavour of Linux as a development environment (so, apologies if I am showing something really obvious). Haskell development in Windows doesn’t seem to be the default :D (Haskell Platform installs and runs super well on Win7 and 8 BTW) but trying to learn in a non recommended environment is probably not a good idea. To that effect I am creating an Ubuntu vm to serve as a development environment for Haskell

These are the steps I went through:

Install virtualBox
Used Vagrant to get a desktop Ubuntu (tho probably it would have been easier to just install from iso)
I started of with a 64bit machine but something went wrong along the lines (convoluted) and decided to start again
The machine was Ubuntu 12 I used Ubuntu Software updater to update to 14.04, the current version.
From there I could sudo apt-get all the way to install Haskell Platform this way , this installed ghci 7.6.3
I also installed leksah as suggested by @bodil, thanks :D
When I tried to create a cabal sandbox I hit a problem, the update looked fine (ie no errors ) but the cabal version remained at 1.16 :(. To do a cabal update you have to call
```
cabal update
cabal install Cabal cabal-install 
```
Thanks to @TailCallingDev (btw check out his blog, seriously), I had to add cabal to the path like this:

in .profile

# set PATH so it includes cabal
if [ -d "$HOME/.cabal/bin" ] ; then
    PATH="$HOME/.cabal/bin:$PATH"
fi

Also the version of ghc I was on doesn’t play nice with cabal > 1.22 so after updating the path I had to call the cabal install command this way:

cabal install cabal-install --constraint="cabal-install < 1.22"

The source of this cabal + ghc seems is better described here

And then I called leksah on the terminal and it worked!

This is all for today, will update this post with a link to this VM hosted somewhere, as It might be useful to someone.

Another Day, another pain

I couldn’t install glfw easily so I decided to create a new vm 😑

New vm was easy, got ubuntu 14.10 because it had the glfw package (it seemed easier to do this than to build from source)
First thing I did was instal libglfw and it seemed to work
My resolution was 640x480, not fun -> resolution problem Solutions for low screen resolution in Ubuntu 14.04/14.10 and VirtualBox
glfw installed yay!

sudo apt-get install libglfw3

It would have been cool to have a some sort of way to know that the installation worked

for FTGL I had to use

sudo apt-get install libftgl2

It did work

Installed leksah
Ran leksah and ran the welcome and I get a message “cabal does not exist”, not sure what to do here
Installed sublime and SublimeREPL and this just worked, at this point I wanted to get something working
Build the code I got from the repo and it failed with cabal dependencies because I had an old version of ghc, the way to solve the problem is here so, the good news is that there is a reliable source to where to get binaries :D

After doing this I was able to build the project however I can only run a few of the projects, some fail requesting that I enable 3d acceleration, however when I do this, the vm doesn’t work well.

Many people have mentioned Halcyon it’s a way to handle dependencies in Haskell projects in a saner way. My understanding is that it doesn’t require cabal or ghc to start, builds from source and keeps the binaries you need somewhere for you so that you have the same setup every time and you can share this with anyone that is working on that project. I think my understanding of this is a little incomplete so I recommend you have a look at it if you are interested.

my feelings exactly:

escaping cabal hell is like untangling a ball of yarn pic.twitter.com/7EEnAQPxWR
— Kat Chuang, PhD (@katychuang) February 7, 2015

Comments, questions, feedback as always welcome.

What is a type system

Wed, 31 Dec 2014 11:44:00 +0000

Curiosity killed the cat, good thing cats have 9 lives…

I don’t know you, but after using a few programming languages I have too many questions about type systems, some that come to mind:

What is a type system?
What is a type?
Do we need a type system?
When do we not need one?
What is the relation between type systems and property testing? or is there one?
Why is category theory so important in advanced type systems? (I have intuition but no concrete answers yet)
Are there pure definitions and implementations for the different types of types systems?

Probably some of those questions make no sense, at least, until I understand the answers.

Thankfully, I was not alone in asking myself questions. For example this question seems to spiral into no concrete answers.

If you are looking for a post about Strong vs Weak typing and Static vs dynamic typing articles I found a this one (there are many more)

What To Know Before Debating Type Systems

Anyway I am starting off with the first question.

What is a type system?

According to

Wikipedia In programming languages, a type system is a collection of rules that assign a property called a type to the various construct—such as variables, expressions, functions or modules—that a computer program is composed of.1 The main purpose of a type system is to reduce bugs in computer programs2 by defining interfaces between different parts of a computer program, and then checking that the parts have been connected in a consistent way. This checking can happen statically (at compile time), dynamically (at run time), or it can happen as a combination of static and dynamic checking. Type systems have other purposes as well, such as enabling certain compiler optimizations, allowing for multiple dispatch, providing a form of documentation, etc.

Ok, a bit generic, but helpful:

There are rules
There are constructs
A program is composed by the aforementioned constructs
type systems help prevent errors

Other definitions I found online are as simple as:

A type is a label (can’t remember who said this)
“…A type is simply a name for a collection of related values just like a food group, it’s a name for a collection of foods with related properties and a type is a name for a collection of values that we code with that have similar properties” From Erik Meijer latest course on functional programming (Lecture 2 part 1)
Benjamin C Pierce from TAPL A type system is a tractable syntactic method for proving the absence of certain program behaviours by classifying phrases according to the kinds of values they compute.

This is a more helpful

Tractable and syntactic method
absence of behaviours (perhaps runtime errors)
Classification of phrases according to kind of values

As I was thinking a little about this I found this gem of a post:

@mrb_bk wondered What is a type system for This is totally worth the read. The post is based on studying TAPL. The TL;DR of the post goes like:

"The most basic property of this type system or any other is safety (also
called soundness): well-typed terms do not 'go wrong.'"

What does “go wrong” means in this context?

"...it means reaching a 'stuck state' that is not designated as a 
final value but where the evaluation rules do not tell us what to do next."

In this context thinking of getting stuck as runtime errors is acceptable.

"What we want to know, then, is that well-typed terms do not get stuck. We 
show this in two steps, commonly known as the progress and preservation 
theorems."

The theorem definition and explanation is in the post, but I had to stop and thing about:

"Safety = Progress + Preservation"

That is where I am going to leave this for today.

Worth Reading

As a novice in this area I found The paper by [Luca Cardelli][1] is a good read .

Also this pdf by Benjamin C. Pierce contains an overview of the available literature up until year 2003.

Is C# a strongly typed or a weakly typed language? Eric Lipert’s blog
Types systems- The good, the bad and the ugly A highly controversial talk about type systems that I enjoyed greatly, I hope conferences keep bringing talks that people have string feelings about.

References

Type Systems for Programming Languages It’s a scary one
Practical Foundations for Programming Languages

Feedback other resources?

Do you know of other type system resources I should look into? Do you know of any other links I should look into? Any comments? Let me know

Happy new year!!

FSharp and games in celebration times

Fri, 12 Dec 2014 11:44:00 +0000

The title of this post was a bit obscure as I didn’t really know what I was going to do for this entry on the #FsAdvent Calendar Make sure you check out the previous and future entries in the series.

For today, I thought we would celebrate with sound, in the Key of F# :D

src reddit

To that effect we can use OpenAl. To be honest this was a little more difficult to do that it needed to be, mostly because there was plenty of playing around with values to make sure stuff worked and sounded somewhat ok.

The good thing about this sample is that you can run the sample either via a console app or in F# interactive (make sure you change the path to your location of OpenAl, you should get the NuGet package called OpenTKWithOpenAL) Disclaimer this is the first time I play with vanilla OpenAl (it will probably show).

Bird’s eye

The end goal is to transform something like this "F# F# G# F# F# D# D# D# F# F# G# F# F# D# D# D#" into a collection of numbers that represent a wave, then we can feed that into OpenAl for it to play. The graph below represent one note (generated with F# Charting)

Step by Step

To start off you need a context, a buffer and a source, these are OpenAl requirements.

use audioContext = new AudioContext()
let buffer = AL.GenBuffer()
let audioSourceIndex = AL.GenSource()

Then we need to get something to play, if our input is a string with the whole song then we can do something like this to get the frequencies calculated for each note

    let toFrequency (note:string) =
        match note.ToUpper() with
        | "C" ->  261.626f
        | "C#" -> 277.183f
        | "D"-> 293.665f
        |"D#"-> 311.127f
        |"E"-> 329.628f
        |"F"-> 349.228f
        |"F#"-> 369.994f
        |"G"-> 391.995f
        |"G#"-> 415.305f
        |"A"-> 440.0f
        |"A#"-> 466.164f
        |"B"-> 493.883f
        |_ ->  369.994f (*Defaults to F# because xMas ;) *)

I was thinking we could have a discriminated union here, however this seemed to serve the purpose of this example in a simple and concise way.

You might be wondering how I came to those numbers, well turns up the internet is great for this sort of thing, they can be found here. Tried a few octaves and these were the ones I preferred.

Then, with some research into the OpenAl docs and a bit of reading into Duality’s source code this is how we can convert those frequencies into data that can be played.

    let samplingFrequency = 44100.0    
    
    let generateNote (freq:float32) =
        let noteLength = 0.5
        let seqLength = int  (samplingFrequency * noteLength)
        Seq.init seqLength (fun i -> 
                    (2.0 * Math.PI * float freq) / samplingFrequency * float i
                        |> Math.Sin                        
                        |> ( * )  (float Int16.MaxValue)
                        |> int16
                        )

As mentioned in the first section, we are using 44100 as the base frequency, to simplify things the note length is set to half a second, however this is something that could be easily changed to support different lengths. Then we are creating a sequence that is half the frequency, and the reason for that is this is the number of samples required. Each item in that sequence is part of a curve that represents the sound for that given note (the freq parameter).

With those two key functions you can create the complete collection. In this case Seq.collect really shines, it is perfectly suited to what we need to do:

Combines the given enumeration-of-enumerations as a single concatenated enumeration.

        let freqToWaves = toFrequency >>  generateNote
        let data = notes                        
                        |> Seq.collect freqToWaves                        
                        |> Array.ofSeq

Finally we use OpenAl to actually play the wave:

	AL.BufferData (buffer, ALFormat.Mono16, data, data.Length * 2, samplingFrequency)
	AL.Source(audioSourceIndex, ALSourcei.Buffer, buffer)
	AL.SourcePlay(audioSourceIndex)

There is a mystery song you can play (in the key of F#)

You can see it all together in this sample here

Summary

Try it, you will probably love it. Another little toy to play with during the jolly season.

Thanks to Sergey and the F# community for this cool FsAdvent.

Also thanks to everyone (yes you, you rock!) for a truly amazing year.

The gif below seems completely unsuitable but you are here already :)

FAKE, What is it and Why you should check it out

Tue, 09 Dec 2014 11:44:00 +0000

I have mentioned FAKE (aka F# Make) in pretty much all the talks I have done lately, however I never explained in detail some of the key aspects of this amazing build DSL.

FAKE is a build automation system with capabilities which are similar to make and rake. The DSL includes support for:

building with MsBuild + xbuild
Testing with nUnit, xunit, MSpec
Creating nuget packages
Ziping resulting files
More!

Good to know

It’s mature. I want my build scripts to be reliable and easy to change, if this was a toy project by someone I would be a little hesitant in recommending, however with over 4 years in development, FAKE is a mature project.
Builds for .net and mono, it’s cross platform. (disclaimer I don’t use mono in production so I haven’t felt any pain on that) However I some people do.
Builds C# projects too. It might be obvious to some, but FAKE builds C#, VB and F# projects :D.
No need to know F# to use it. As much as I like F#, some might consider the language a barrier, I have shown to more than one non F# developer FAKE scripts and they understand what is going on. There is a real benefit on having a build system built on a strongly typed language. Also check out a really good article called FAKE Everywhere.
Integrates with CI Servers. The integrations I know of are TeamCity, MyGet and Appveyor. We use both TC and MyGet and they work nicely.

When do we use it

From the very beginning we have been using TeamCity as our CI server for a long while, however having one click builds is really powerful.

Debbuging. We have about 20 different solutions contributing to making the game we work on a reality, sometimes, when something go wrong we need to debug certain aspect of the game, as the game runs, the thing is, building and copying the dlls in the correct places can be error prone, we avoid that by building with FAKE and copying to a given path automatically, all with F# and FAKE
Different targets. x86, x64 builds as well as custom targets (for example we have one for Steam(the PC games store)
Deployment. We have to remove certain content and package the game with just the bits needed to run, this requires some custom removing and adding of things at the right time.

A great way to learn is by checking out some OSS projects:

Summary

Try it, you will probably love it.

Resources

NDC London slides

Mon, 24 Nov 2014 11:44:00 +0000

You can find my slides and Video for NDC London.

CodeMesh braindump, notes

Mon, 24 Nov 2014 11:44:00 +0000

I took some notes during CodeMesh a few weeks ago, and here they are. There are a few good talks that I couldn’t attend that are totally worth it, check them out when their videos become available.

Last year, CodeMesh showed me a lot of what I felt I was missing. This year was also quite amazing, the talks and people made it totally worth it. These are some notes I took during the talks, not sure they would help anyone, you never know.

QuickCheck tutorial

shrinking, find hints in shrinks. Mostly deterministic to help you find hints fast
when comparing you need to find the simplest thing to compare to
Stats help you check if the calls make sense
There are pre and post conditions
generally you discover many bugs with one property
Race condition -> makes calls in orders humans wouldnt do it because it doesnt make sense to us
quick check CI

Idris tutorial

Idris is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program’s behaviour can be specified precisely in the type. It is compiled, with eager evaluation. Its features are influenced by Haskell and ML.

pacman ready
Vim or Emacs
think of proofs

It is hard to explain in these lines what the experience was like. Writing Idris was more like doing Maths or Algebra that it was to write code, I wold say that is something you want in some cases. You can find windows binaries here It felt like the code needed to balance itself. The editor environment was a huge help as it helped reduce statements.

Keynote: Jessica Kerr and Dan North

Great keynote that made us all think about the systems we write, about all the concerns we need to be aware of.

estimation by range , the bigger the range the bigger the unknowns
introduce research as part of all sprints

Not all of us build software with a narrow specific focus

Gamedev-grade Debugging - Leszek Godlewski

This session felt like therapy, all the crazy bugs that are gamedev specific, exposed

Three types of bugs: temporal, graphical, content.
sometimes terrible hacks,
Domain specific debuggers

He also recommended and missed Valgrind. The Valgrind tool suite provides a number of debugging and profiling tools that help you make your programs faster and more correct. The most popular of these tools is called Memcheck. It can detect many memory-related errors that are common in C and C++ programs and that can lead to crashes and unpredictable behaviour.

Yan Cui, Neo4J

Very cool tool about the complexity of their game and economy and how they are using this graph database to curb it. I am not sure we can/should use this because we don’t have the same scaling issues, but great to see none the less. Awesome style of presentation too.

Behaving in the 21st Century - AI Productivity through Tooling - Emil Johansen

Slides

Emil presented a tool he built for Behaviour Trees, the tool generates behaviour code. I really liked the demo he showeed My main take on it was that I am glad to see tools like this

BTs as iterative tools
code generation
A different workflow (to ours in Duality)

The tools that shape us

I’m going to do this the other way around and tell you how was it for me to prepare this talk, because …coverage and correctness (and as a test).

The talk was about highlighting the importance of tools, and how important it is for us to make sure we provide good tools for others to work with. As developers our tools are also important:

Languages
Ecosystem
Communities

Tools model the way we think, and so it might be worth trying out something totally different just to see what though process it bring us.

Alex Champandard

Talked about AI on the GPU. Great talk and presentation. Not only content but style (impeccable)

OpenCL and what we can do
can do A*
Separate GPU for processing and rendering
Sycl
A lot of cool ideas perhaps not ready for production yet.

Ramsey and Tims

This is the second time I see this presentation however, it was totally different than the last time I saw it

Simplify game development by using a more terse language (I can relate 😄 )
Arcadia, using CLR implementation of Clojure on top of Unity.
REPL as a way to game design
extra bonus points because they showed a game with cats!

Keynote: Chad Fowler

The theme of the keynote was tiny
Big tends to fail
Some of his experience with failure
Where are we now.

Left me thinking, which is the purpose of all keynotes.

Typed Clojure in Practice - Ambrose Bonnaire-Sergeant

I was really curious about this because I imagined it would be hard to add typing to a lisp, as a noob, that only did the equivalent of a hello world in clojure. I have to add, Ambrose passion and enthusiasm for this project is contagious

Functional Patterns in Domain Driven Design applied to Financial Models - Debasish Ghosh

Modelling in financial
Introduced some algebra at a nice pace, logically.
Financial with cool examples

Naming things - Ian Barber

A lot of stuff to think, but didn’t take notes, worth a watch when it comes online.

Gluing Things Together with Haskell - Neil Mitchell

Really liked checking out Shake and Bake, and how people are deplying things in Haskell. Great presenter too.

Summary

As you see, my notes got sparse towards the end, but … I’ll learn to take better notes hopefully. Again, one of the most interesting things about conferences is that, you get to talk to a lot of people thinking similar or totally different thoughts to yours about similar topics. Left inspired and looking forward to next year!

Converting a small game from C# to F# part 2

Tue, 30 Sep 2014 11:44:00 +0000

This post could also be called:One step forward, two steps backwards.

I thought I should rewind a little bit, and have an overview of the game before we continue.

The C# version of the game has 9 files and each, each has a class where (generally a component is defined), I decided to change this for the F# version of the game, tho I am not sure type per file is an idiom of F# or not. (Comments on this, really welcome)

The idea of doing this port is to show the progression of the code from C# to F# to (hopefully) better F# so if you have some comments on how to improve, they are super welcome, particularly commenting with code samples (or PRs). The whole game (in C# and F# and the editor ) is all available from this github repo.

About Duality

The engine, Duality, is a C# engine that follows some of the C# idioms. It is not in our immediate plans to make a wrapper to make the engine more f# friendly, I find don’t find it too hard to work with the two languages, however it might be because I am familiar with it enough to not feel much of the pain.

These are bits of code we will se over and over

Is it a bit humid here?

Declaring a component. Needs to be serializable, and inherit from component

[<Serializable>]
type LifeMeter() = 
    inherit Component()

Most of these components will need to implement ICmpUpdatable or ICmpInitializable

    interface ICmpUpdatable with 
        member this.OnUpdate() =
            //Do some componenty stuff here

Some components need to be able to detect collisions, on those situations you need to implement ICmpCollisionListener

    interface ICmpCollisionListener with 
        member this.OnCollisionBegin (_, args)=
			// Do collision stuff here (or somewhere else)           
        member this.OnCollisionEnd(_,_)=  
            ()
        member this.OnCollisionSolve(_,_)=  
            ()

I don’t think I mind the interface implementations.

Then there is the find the (not null) component. In the example below we are looking for a TextRenderer within the object. In the None matching, it is more likely you want to log and editor warning, rather than do nothing

            let tr = OptionComponent<TextRenderer> this.GameObj
            match tr with
            | None -> ()
            | Some tr ->tr.Text.SourceText <- sprintf "Score: %i"  score

What does all of this mean? well I though it might be useful to summarize what I have seen so far. I’ll update this post with more if I think of any other repeating pattern.

Until the next time :D

Converting a small game from C# to F# part 1

Mon, 15 Sep 2014 11:44:00 +0000

As part of the workshop I am preparing to run on a bunch of places in North America, I created a small clone of Breakout and just ported it to F#. I am going to be explaining a little about how the engine works and that will be intertwined with an (hopefully) fun intro to F#.

Duality is

A 2D game engine that comes with an extensible visual editor.
OSS (MIT license).
Written on C# and OpenTK.
the architecture is built around a plugin system.

Follow the link for Adam’s getting started.

In the previous post I showed how to create components in Duality, so I started of with one the simplest component, ScoreComponent, that component looked like this

    [Serializable]
    public class ScoreComponent : Component, ICmpUpdatable
    {
        private int _score;

        public int Score { get { return _score; } }

        public void IncreaseScore(int amount)
        {
            Score += amount;
        }

        public void OnUpdate()
        {
            var textRenderer = GameObj.GetComponent<TextRenderer>();
            if (textRenderer != null) 
                textRenderer.Text.SourceText = "Score: "+ Score;
        }

    }

When converting to F# it looks pretty similar, at least initially

[<Serializable>]
type ScoreComponentF() = 
    inherit Component()

    let mutable score =0

    member this.Score = score
    
    member this.IncreaseScore amount =
        score <- score + amount        
    
    interface ICmpUpdatable with 
        member this.OnUpdate() =
            let textRenderer = this.GameObj.GetComponent<TextRenderer>()
            if (textRenderer <> null) then
                textRenderer.Text.SourceText <- sprintf "Score: %i"  this.Score

The method OnUpdate could be improved. A first iteration would look like:

    interface ICmpUpdatable with 
        member this.OnUpdate() =
            match this.GameObj.GetComponent<TextRenderer>() with
            | null -> ()
            | textRenderer -> textRenderer.Text.SourceText <- sprintf "Score: %i"  this.Score

This is nice but this pattern(?), do something if the component exist, is rather common and it would be nice to turn this into an option type.

We will continue in the next post :D

Fun and games FTW!!

OT: Best of luck to all the people involved in Minecraft and this transition to Microsoft. I can empathise with where @notch is coming from.

Writing Duality Components in FSharp

Mon, 08 Sep 2014 11:44:00 +0000

Duality is a 2D game engine with an extensible editor (If you follow my blog you’ll see it mention it a few times), I added F# Scripting support a good while ago but I haven’t been posting too much about it, I probably should change that.

Scripting is not the only way to use F# on this engine, you can also create components with F# and it’s pretty simple.

When you run Duality on a folder that has no Data, it creates a solution for plugins by default in Source/Code with two projects: CorePlugin and EditorPlugin. Open the solution and add a F# project. Once it’s created open the project properties and change the assembly name so that it ends with “core”

Add a reference to Duality.dll and OpenTk.dll (you will find this on the game folder, alternatively have nuget packages too in MyGet )
Add a new file to the project, it must inherit from Core and read like this

open Duality

type BreakoutFSharpCorePlugin() = 
    inherit CorePlugin()

Lastly if you want to F5 to launch the editor you can add the following to the end of Editor.csproj.user file (replace DualityEditor.exe locations )

  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
    <StartAction>Program</StartAction>
    <StartProgram>Pathto\where\editor\is\DualityEditor.exe</StartProgram>
    <StartWorkingDirectory>Pathto\where\editor\is</StartWorkingDirectory>
  </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
    <StartAction>Program</StartAction>
    <StartProgram>Path\to\DualityEditor.exe</StartProgram>
    <StartWorkingDirectory>Path\to\where\the\game\is</StartWorkingDirectory>
  </PropertyGroup>

####Example This is an example of a component

open Duality
open System

[<Serializable>]
type ScoreComponentF() = 
    inherit Component()
    let mutable score =0

    member this.Score = score
    
    member this.IncreaseScore amount =
        score <- score + amount

F#n and games

Sun, 31 Aug 2014 11:44:00 +0000

F#n and games

I am extremely happy to announce that after Strange Loop a conference I am lucky to attend!. I will be going about North America showing off some F# and games!

I will in the following user groups

Tuesday 23rd September - Nashville NashFP
Wednesday 24th September - Washington DC
Tuesday 30th September - Toronto

I will be updating the details of the times here as I learn about it. I hope to see you there!

Game on!

It is way more entertaining to learn by doing. To that end we will be using Duality (an open source game engine) with a F# plug-in (also OSS) to create power-ups (or power downs? ) to Breakout.

It is very possible I’ll be attending the amazing F# Progressive tutorials in New York, the line up is pretty good, and suitable for both beginners and advanced f#ers. If you are close and into functional programming, this looks like a great conference and Don Syme, Scott Wlashin, Rachel Resse and more involved in it.

More Game at GameCraft

On October the 4th at GameCenter NYU New York GameCraft is happening. In this 12 hour event, you have 10 hours to start and finish a game with a given theme (the theme is announced on the day), in case you are wondering the extra 2 hours is to play each other games and get prizes!. You can use any technology you want. If you never took part on a game jam I would recommend you do, the first question I get generally is: What skills do I need? you need to want to make a game, and quite possibly a laptop. Phil Trelford is no stranger to GameCraft and wrote a lot about it in his blog. Attendance is free but you need to register . Thanks to SkillsMatters and Game Centre NYU for helping make this event happen.

Thanks to fsharpWorks for Sponsoring this trip!

Hi, Halpz!?

If you have any tips, suggestions, ideas on how to move around the cities I will be in, or want to meet up, that would be great!! Just leave a comment here or I am on twitter @silverspoon

Build tools FTW

Sun, 10 Aug 2014 14:13:00 +0000

At the moment, and for the last while, I have been working on an awesome game OniKira: Demon Killer (yes we renamed it recently) from the start we wanted to have a one click deploy, and I believe in walking skeletons…, so, I have been working on having a one click build since the beginning of the project and as we are getting closer to a Steam Early Access for the game and need to send different types of builds to different parties this is really starting to pay off.

Current Tools

This is a list of tools we are using for the build:

TeamCity: for building, running tests, etc. I love this tool, like most of jetbrains tools I used over the years. I am curious about their new offering UpSource .One suggestion: I wish it would be for the UI would be turned into some script so this could be into a repo rather than a database (I am sure there are good reasons for this but this is what I want right? :D)
ScriptCS: There are some custom moving of assemblies depending on target platform, packing of textures, and other crazy stuff with ScriptCS I have little friction and I can script fast in a language I know well (kudos to Glenn Block, Justin Rusbatch and Filip Wojcieszyn)
BitTorrentSync: Build distribution peer to peer. We are a small however diverse team (ie not all of us that need to have access to the build are developers) this is a pretty efficient and cost effective way to do that. We also use this when editing video or other large binaries.
MyGet: A lot of the code we write is open source, we pack it and ship assemblies using NuGet via MyGet. Their response time is amazing (I had a problem once and they responded and fixed a problem in less than 30 minutes, note: I created the problem in the first place ).We have started migrating some of the builds to their build service.
git: for all code repositories.
svn: Content repository (images, sounds, binaries)

Tools on Testing Phase

Recently I added #FAKE to our Duality(game engine) build, I was able to do something a custom with the build in a couple of hours (generally custom in build tools is a pain), and it has TeamCity integration so this is something I might use on the next build task I have.

Thank you

All of these tools are free (at least the way we use them to build and many of them are open source. Thanks to all of you that make this possible.

NuGet install tricks

Sun, 03 Aug 2014 14:13:00 +0000

Recently I was finishing off the great work Carsten started (well pretty much completed, I was just adding the nuget package and change the build so it would build the aforementioned package ) on the Nunit add-in for FsCheck and I had to use a not very common feature of Nuget, running powershell scripts automatically on install.

Disclaimer: I don’t like powershell, it is better than nothing, but every time I use is harder that it needs to be.

Running powershell scripts automatically when installing and removing packages

There are a few powershell files that run (if they exists on /tools in your package definition): Init.ps1 , install.ps1 and uninstall.ps1 Init.ps1 runs the first time a package is installed in a solution, install.ps1 runs when a package is installed in a project, uninstall.ps1 runs when removing the package. There more information about these files here in the section called “Automatically Running PowerShell Scripts During Package Installation and Removal”

The script

In the docs above, when you are looking at what you can do regarding project, it refers you to this page hint there is no info about Object :/. Thankfully I was pointed towards SpecFlow’s install.ps1 file.

I ran into a little problem when building this, I had specified a path wrong on my script and this is the error I got:

 Exception calling "Add" with "1" argument(s): "Unspecified error
 (Exception from HRESULT: 0x80004005 (E_FAIL))" At

 + $project.Object.References.Add <<<< ($NunitRunners+"nunit.core.dll")
     + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
     + FullyQualifiedErrorId : ComMethodTargetInvocation

Just for completeness this is the final install.ps1

param($installPath, $toolsPath, $package, $project)

write-host "Adding a reference to nunit.core and nunit.core.interfaces to the project"
$packagesFolder = Split-Path -Path $installPath -Parent
$version = ""

# Get-Package -Filter NUnit.Runners also returns packages with NUnit.Runners in the description (e.g. NUnit or SpecFlow.NUnit.Runners)
# we need to find the one, that we are looking for
$nunitPackages = Get-Package -Filter NUnit.Runners
foreach ($nunitPackage in $nunitPackages)
{
	# there is a bug in NuGet: the package id for all returned packages is "NUnit.Runners", so filtering that is not enough
	if ($nunitPackage.Id = "NUnit.Runners" -and $nunitPackage.ProjectUrl.ToString().Contains("nunit")) 
	{ 
		$version = $nunitPackage.Version.ToString() 
	}
}

if ($version -ne "") 
{ 
	$nunitPackageToolsLibFolder = $packagesFolder + "\NUnit.Runners." + $version + "\tools\lib\"
    
    write-host "The nunit location is: " + $nunitPackageToolsLibFolder
    
	$nunitCoreInterfacesRef = $project.Object.References.Item("nunit.core.interfaces")
	if ($nunitCoreInterfacesRef) { $nunitCoreInterfacesRef.Remove() }
	$project.Object.References.Add($nunitPackageToolsLibFolder + "nunit.core.interfaces.dll")
    
    $nunitCoreRef = $project.Object.References.Item("nunit.core")
	if ($nunitCoreRef) { $nunitCoreRef.Remove() }
	$project.Object.References.Add($nunitPackageToolsLibFolder + "nunit.core.dll")
}

I am writing this mostly because I didn’t find many blog posts about this.

Some other random NuGet features

I don’t do a lot of nugeting(?) but there are a few features I think can be very useful:

You can specify assemblies that will be referenced (and have more assemblies available on the files tag )
You can use the content folder in the manifest and add files to the project you are installing the package. More info here search for the Content Files section
You can target different frameworks

I like adding pictures to posts, in this case the most representative one might be this one, the view of the project with just installed package with the added FsCheckAddin.fs , and references to nunit.core and nunit.core.interfaces.

Till the next time.

Devsum14-Like a rabbit in headlights presentation slides

Sat, 24 May 2014 14:13:00 +0000

Went to #devSum14 in Stockholm and had a great time. Talked to amazing people and gave my second presentation on F#, people seemed happy about it and had loads of questions :D.

If any of you attended and have some questions or feedback I would love to hear about it.

Any questions, comments and corrections very welcome as always

Why F sharp and functional programming in general.

Sat, 10 May 2014 14:13:00 +0000

Why I have been learning F# (and functional programming in general) lately:

It’s functional first, so it encourages you to write pure functions and other cool stuff.
No more NullReferenceExceptions (wooohoo yeah! PARTY NOISES!!)
Amazing type system. Think type inference on steroids and automatic generalization.
- Tuples: it is great to be able to have multiple results for a function
- Discriminated Unions
- Records
- Moar. There are other f# Types
Open source
Great community
Great interop with C#
Cross platform
Type providers
Forward pipe operator and the opposite
It supports imperative and OO paradigms too
F# interactive

I though it would be good to expand on the points above

##Functional first

At some point during last year as I watched a talk by Bodil Stokke, called Programming, Only better (go watch all the videos of her talks, she is super smart you will learn a lot) in the talk she mentioned a paper called “Out of the tar pit” both talk and paper made me think about the way I code. The end result of watching and reading was that I finally understood that side effect free code is better because it is simpler. We all know that writing simple code that does exactly what you imagine the code is doing is pretty damn hard, and functional programming can help making this a little simple. I feel that by trying to do a little synopsis of what the paper and Bodil said is doing a disservice to both, so go watch and read, beats whatever else you are doing :-D.

This and going to Code Mesh last year is what made me go from a person curious about functional programming, to “I have to learn and truly understand at least one functional programming right now!.

##No more NullReferenceException

The F# compiler will still have to deal with NullReferenceExceptions when dealing with .net types, however when dealing with Option type you can use pattern matching to match all the cases.

let num = Some 1
let notnum = None

match num with 
| None -> printfn "num is None"
| Some x -> printfn "num is %i" x

There is an in-depth post about this here.

Amazing Type system

As a C# developer I always thought C#’s type system was pretty good, it did everything I expected, and rarely let me down. However, I am rather impressed by how much type inference and automatic generalization add to F#. Type inference allow the F# compiler figure out the types use and where, it does so in order top to bottom, left to right. I am thinking perhaps the only annoying side effect of this is that you have to set an order to files in a project, something I find rather weird. Anyway, when the compiler doesn’t find what type to infer then (as far as I know)it makes the code general (imagine implementing that in C# :D) this happens because of automatic generalization (I have 90% confidence of this being correct) I still don’t know exactly how it all works but I am very happy with the results because I can try anything I want quickly. I guess F#’s type system was bound to be good, after all, static typing was first implemented in a functional programming language, .

Tuples

Tuples are one of the F# types, they represent a pair, triple or larger combination of types. This means you can finally do multiple return types :D

let personInfo =
    "Tayla", 45454545

let myFunction =
    let name, number = personInfo
    printfn "name is %s, number %i" name number
    printfn "Name is %s, number %i --" (fst personInfo) (snd personInfo)

And this is what shows in f# interactive :

name is Tayla, number 45454545
Name is Tayla, number 45454545 --

val personInfo : string * int = ("Tayla", 45454545)
val myFunction : unit = ()

An advantage of using tuples is that when you are working with .net types that have out parameters, F# automatically turns that into tuples. Exmaple

open System.Collections.Concurrent

let convert =
    let collection = new BlockingCollection<int>() 
    collection.Add 4
    collection.TryTake()

val convert : bool * int = (true, 4)

As you can see this returns convert : bool * int, when you see a * in the result section of f# interactive that means that the type is a tuple

Records

Yet another F# type, I really like it because it makes classes definitions look like giganto-monsters. Also, tuples are great, but sometimes you want to name things so that ordering is not important.

type vector2Data = { x: float; y: float }

let equal = 
    let vect1 = {x = 1.0; y= 4.0}
    let vect2 = {y = 4.0; x= 1.0}
    vect1 = vect2

Discriminated Unions

This is another f# type. I think an example will speak for itself.

type Weapon = string
type Move = string
type Behaviour = string
type Character =
    | Player of Move * Weapon
    | NPC of Behaviour
    | Scenery

let jiro = Player("Throw", "Katana")
let tree = Scenery
let mempoWarrior = NPC("Chase")

The fsi console returns

type Weapon = string
type Move = string
type Behaviour = string
type Character =
  | Player of Move * Weapon
  | NPC of Behaviour
  | Scenery
val jiro : Character = Player ("Throw","Katana")
val tree : Character = Scenery
val mempoWarrior : Character = NPC "Chase"

As it’s probably obvious this is a great way to work with finite set of choices, pattern matching can be used on discriminated unions.

Open source

This is really what made me choose F# over other languages that I was considering learning. Since the language is open source and owned by the community, it is not tied to Microsoft and it’s rather erratic decision making of the last few years. The C# interop just works.

Great community

Many f# people in twitter and very vocal and welcoming. F# power tools is a must have add-on. But also: FAKE, FsCheck, Fuchu, many type providers.

Supports imperative and OO paradigms

Being able to use pre-existing libraries and paradigms can be very useful.

Great interop with C#.

I’m sure there is a lot more to it, but the main thing for me is that it makes testing C# code shorter, and works both ways.

Cross platform.

It runs on mono and there are people using F# with Xamarin tools for mobile. Also F# has an OCaml compatibility mode (that I haven’t tested yet). The experience on non windows machines keeps improving. And in windows it is really nice once you get F# Power Tools. Before I installed that I found the significant whitespace a bit confusing, but now I literally can see what is the problem.

Type providers

This is a feature of F# 3.0, with them you get typed access to a wide variety of data sources, without requiring code generation. There are a few common type providers included . This means you can do a lot of data exploration with very little

open FSharp.Data

type Languages = FSharp.Data.CsvProvider<"../languages_Ireland.csv">

let readLanguageData =     
    let path = "../languages_Ireland.csv"
    let data = Languages.Load(new FileStream(path, FileMode.Open))

That is pretty much all you need to start playing with the data of a csv file. And by playing I mean you have typed access to the fields in the csv. This will print in the console the fist response (not a great use), but it show that it’s typed, see the %s and that I can access fields by column name (it will use by default the first row for headers)

	let first = data.Rows |> Seq.head
    printfn "The first person production language %s" first.``What programming language(s) are you using in production?``

I don’t know you, but I am totally blown away by this. There is also a graph tool that will help you plot data.

Other people

Just for the craic (and to double check on my madness level) I asked on twitter what is people’s preferred language feature and this is what I got:

@silverSpoon There are so many, pattern matching and active patterns are pretty awesome.
— Dave Thomas (@7sharp9) May 10, 2014

@silverSpoon Because they dramatically simplify logic processing and collapse a lot of boilerplate.
— Dave Thomas (@7sharp9) May 10, 2014

@silverSpoon I just love pipe forward and pipelines of functions. Simple, and makes workflows / data transforms super clear.
— Mathias Brandewinder (@brandewinder) May 10, 2014

@silverSpoon quotations are very cool
— gregyoung (@gregyoung) May 10, 2014

@silverSpoon What I miss the most in C# is DUs. To make them usable you need pattern matching.
— Robert Jeppesen (@rojepp) May 10, 2014

.@silverSpoon Function currying because, like curry, once you start using it you can't stop
— Patrick McDonald (@PaddyMcDonald) May 10, 2014

@silverSpoon @nikhilsingh favorite feature #fsharp Data.SqlClient, I use every day, it works, authors very responsiv https://t.co/9y3H8LzOF4
— Jack Fox (@foxyjackfox) May 10, 2014

@silverSpoon @c4fsharp piping stuff because you it gives an exellent flow to things
— Erlend Wiig (@ErlendW) May 10, 2014

Summary

It might seem like there is a lot to know to just even get started, but I think if you just jump right in, you have a lot to win. Most of the names of the features come from a maths background, it can feel a bit of putting, but it’s really not that bad. Maybe it’s because diving into a new language is just new and exciting, but it’s been a while since my brain reacts so positively to learning something new. Sometimes I get stuck but then that’s when the community aspect really kicks in.

Resources

Another good talk about functional programming for the OO developer from Jessica Kerr

Any questions, comments and corrections very welcome as always

Behaviour trees first attempt at implementing in F sharp

Mon, 05 May 2014 14:13:00 +0000

Recently I saw a post about a simple FSM implementation in F# (link), and that got me thinking about our Behaviour Trees and how simple or complex it would be to implement them in F#.

What are behaviour trees?

There is a longer intro to the topic here and a more extensive one in this paper. What I remember when I think about them is that there are 2 types of constructs:

Actions and conditions: Actions are changes in the game world such as animation plays, health decreased, etc. Conditions check certain states of the world.

Sequences and selectors: This is how we link and order the actions and conditions. Sequences pretty much are what your intuition tells you, they run a sequence of actions or conditions (they all need to return true). Selectors are the flipside of sequences, they run until something returns true.

To refresh the old noodle (ie: my brain) I implemented a very simplistic behaviour tree in C#. It looked like this (there are many classes in one file… you will survive), you can see it here

F# implementation

I tried starting implementing the selector, no luck. I couldn’t figure out what it should look like. Then I tried starting at the top, implementing the implementations of the actions mostly because it was the functions I knew how to implement, and they might guide me to somewhere interesting.

Turns out it pointed me to my total lack of understanding of the F# type system.

Types

It turns out I had to leave my very practical approach to learning F# and go get my read on. I heard that F# has a pretty advanced type system, and I was just about to learn why.

Turns out there is an amazing series of posts about types by Scott Wlaschin. I think there is little point in my replicating what he said in worse prose :D, so go read that, and if you know of another cool link on the F# type system, please let me know by leaving a reply to this post.

Anyway, after a glance at the posts I think I need a discriminated union, or maybe a class but that feels dirty, of course I’ll have to try both.

[Here I took a rather long pause to go and read the posts properly and then do the Koans on records and classes to get my brain warmed up,]

Then I attempted to implement the tree again but getting stuck again. I decided some procrastination might help so, I went to look for some implementations of BT in every functional language I could think of and found these one in clojure (I think these might be slightly different Behaviour Trees), and this one in common Lisp.

I am going to leave this for today but will return with a solution as soon as I get one.

F# scripting for a component based game engine

Mon, 21 Apr 2014 14:13:00 +0000

Recently Andrew added C# scripting capabilities to Duality, the engine we are using to build Honourbound. Once we had something working, we started thinking about the fact that it might be pretty simple to add support for [F#][fsh], so we did.

A few weekends ago I twitted this:

We had a spike working within a few hours with an old version of F# codedom. I spent some time the last few days making it more usable within the editor.

How to use

If you are like me, you’ll want to try this out as soon as possible, instructions :D

Steps to move a gameObject with an F# script if you never used Duality

Download duality with the plugins in place from this link.
Open DualityEditor a scene will be created by default but not saved, save it.
Drop a duality logo from the default folder in Project View into the main area. This will create a GameObject with a
In the game object in the object inspector (if you don’t see it, menu->View-> Object Inspector), right click and add a script component.
In the scene editor, create a folder, call it scripts, right click and go to Scripting -> F sharp script
Double clicking on the newly created resource will open the F# file with your default editor for files ending with .fs.
You will have access to the GameObject and other engine related properties the same way you do in Duality (or Unity if you are familiar with it)

module Dualityscript

open ScriptingPlugin
open Duality
open Duality.Components
open Duality.Helpers
open OpenTK

type FSharpScript() =
    inherit DualityScript()

    override this.Update()=        
        this.GameObj.Transform.Pos <- this.GameObj.Transform.Pos + new Vector3(1.0f,0.0f,0.0f)

If you want to build all yourself :

Build from source from our fork. We are using our fork of Duality instead of Adams, because of some dependencies we have on our own fork, we will see how to make this a better experience, so far I wanted to get something usable out.
Build this get the ScriptingPlugin.core.dll and ScriptingPlugin.editor.dll and copy them into the plugins folder inside the aforementioned Game folder.
from the packages folder copy FSharp.Compiler.Services.dll
from the packages folder copy Mono.cecil.dll and Mono.cecil.pdb.dll

A video showing this here.

Why

Game programming in a middle to big sized project falls into three logical categories. Those categories are associated with their level of use: i.e: how often you run this code, and the rate of change i.e. how many times this file has changed in the last month.

Engine: Core game engine, doesn’t change too often, ideally it has lots of test coverage.

Game Systems: These are game specific systems that are core to the game, the change more often than the engine. This code has a high re usability level so should be tested.

Gameplay: The code here changes all the time, the general pattern is a lot of initial churn and then some tweaks. We agreed not to test this code, tho there are some exceptions.

I think using F# with a functional approach in our GamePlay code will make us more efficient because of the frequency of change this type of code requires. It might help reduce the number of NullReferenceException type of errors too.

Thanks

Dojo fractal forest in F# (with pictures)

Sat, 29 Mar 2014 23:13:00 +0000

A week or so ago I was lucky to be in San Francisco for “the” Game Developer Conference, while I was there I was able to meet Mathias Brandewinder, we got to chat about loads of things (and eat some really nice breakfast) two of the many things we talked about were FsCheck and the dojo fractal forest.

FsCheck is this really cool Pex like tool, I am trying it out and I could attempt to explain it but Mathias already wrote a great post about it in this post, check it out. You can also use FsCheck with NUunit.

The Dojo fractal forest is just a little exercise in F# to make a tree using recursion, I though I should give it a go, it looked like fun.

As I was writing this I was debating weather I should put some code up or not, as it might have a negative effect on people thinking of doing this. I decided against it for the moment. These are the iterations of the trees I built.

When I reached the tree I was happy that I had achieved the goal of the exercise, but what else could I do with it?

Could I give it some leafs?
Could I grow the leafs over time?
Could the colour of the tree change with age (into a multi-coloured tree, because that seems way more fun)

Adding a leaf at the end of each branch was super simple, but that is not how trees work. I had to go find how real trees worked

I need to continue this post later, if you are intrigued you should go and try it out yourself :)

The importance of win times

Mon, 10 Mar 2014 12:13:00 +0000

As most developers I have really good and really bad days, it comes with the nature of the job. Lately I have been thinking that I had a lot of bad days, I needed to feel like I was wining and so I solved a small totally unrelated problem, I felt good. It will surprise no one that after that I was able to suck a little less during that day. Solving that little thing gave me a little bit of confidence I needed.

This event made me think about he amazing book “Zen and the art of motorcycle maintenance”, I don’t remember who said it was the best software development book ever, so I read it last year, and I was thinking about it for a long time. The focus on the book is on quality and what that actually means, in the end you get a general sense about it, not a real answer.

Just for the craic, this is a quote from the book: “Some things you miss because they are so tiny you overlook them. But some things you don’t see because they are so huge”

For some reason this reminds me of something I just did, and that is when you find a potential error, instead of just throwing an error, also try to suggest a solution in the error message… NullException is the most recurrent one

 

	var player = Scene.Current.FindComponent<Player>().GameObj;
	if(player == null)
	{
		Log.Game.WriteWarning("A player is required for this behaviour to work, please add one.");
		return;
	}

In this case this makes sense because this message is for people of a team that is small and the language is informal. I don’t need to do much other than let them know, you might want to react in a more suitable way. Quality is contextual.

Learning F# with Katas

Tue, 25 Feb 2014 10:48:00 +0000

For a while, I’ve been trying to learn functional programming and after a lot of prodding I chose to learn F# this year, the reasons:

I though I should learn Haskell, the ideas behind the language are great. I learned a little bit, but, when I tried to build something with a UI or web or a game, the dependencies just weren’t three. And windows support just doesn’t seem to be there. It doesn’t mean I’ll never learn it, but I just want to get learning.
F# has a great community, I am looking forward to learning more so that I can perhaps sometime contribute some code.
I am a c# developer, using the clr is certainly helpful, and it makes it more likely that I can use the language on a day to day basis. If I do, I’m pretty sure you ll hear about it.

I thought the way to go about it was to do something often, so functional katas started in january and I have started to re-write the last kata after a comment on twitter from Richard Dalton aka DevJoy, thanks for that.

Game AI pro review

Wed, 12 Feb 2014 12:13:00 +0000

TL;DR: It is not everyday that I definitely need to learn from a book. When I got “Game AI pro” I needed to learn as much as possible about practical usage of Behaviour Trees, and it didn’t disappoint.

General Review

These series of books by CRC show a high level of production. It can be intimidating at first, but you should keep going. The book is a compilation of articles from different authors, the quality and depth varies but is generally high.

Having the article on chapter 2 about Neurology was cool to read. It went into more detail than in other AI books and it was refreshing.

I wasn’t interested in Randomness so I am afraid I don’t know how useful those articles are because I skipped them.

All the articles related to Behaviour Trees where relevant and useful to me. There is a few introductory chapters that are well written that explain some options on how to organize your AI.
I found particularly interesting the chapter(?) “Simulating Behaviour Trees: A Behaviour Tree / Planner Hybrid Approach (Daniel Hilburn)”. I had never though about a Monitor and Behaviour Tree combination and it got me thinking. (so many times I would start reading, follow my though path, forget what I read… had to start that section again). For this particular chapter, the sample code was neatly organized. Out of all the authors, perhaps this is the one I would find more useful to have a chat over a beer (and hopefully close to a white board, just in case).

Talking about sample code, Some of the samples are great, others give you something without enough context.

If you are thinking of buying this book you need to be aware that, like most game development books, there is not as much code as you would expect and when there is it is C++ code. If you are looking for practical advice about production AI, then this is the book for you.

CodeMesh presentation slides

Fri, 24 Jan 2014 12:13:00 +0000

Possibly what blew my mind the most last year was attending and presenting at CodeMesh, the conference line-up was impeccable, and of course, the interesting bits happened when talking to people there. Kudos to the organizers for a great conference.

Below please find my slides, they probably make no sense without context. I think the interesting parts of the talk are better explained in two posts about game concurrency here and here

Some pictures and links:

David Turner’s talk is available via this paper “Some history of Functional Programming Languages”

Parallella Board, website

Yan Cui’s slides

Phil Trelford’s video on F# for Trading, to be honest, even if you are not into trading, this is pretty good.

The talk by Dave Thomas and Jose Valim was pretty cool, no video or slides available at the moment :D.

The first Functional Katas meetup

Tue, 21 Jan 2014 22:44:00 +0000

The first Functional Katas happened last Wednesday, out of 29 people who signed up, about 15 turned up. Which is great given that it’s January and cold, and it was raining. An interesting part of going to the kata is that there is no internet access, this is somewhat a problem, at the same time, I kinda liked that extra constraint, perhaps not all the time.

There are a few things I learned from being there. I was pairing with Kevin, who was writing Clojure, a dynamic programming language that targets the jvm (I learned later it also can compile to js and apparently there is an implementation on the clr too), my first impression was that although very powerful … so many parentheses! I guess it is a trait(?) of Lisp, in saying all this please keep in mind I am ignorant in the ways of Lisp so this is truly first impression. It was fun to go and try to do this in a language I had no idea about.

After 50 minutes of writing code, we went over all the solutions, I was really impressed about this. We had solutions in Haskell, Scala, F#, Scheme (with Racket) Erlang and Clojure. One thing that I noticed as we went through the solution is how similar the approaches to solve the problem were, pattern matching is a wonderful feature of functional languages. The code in all the solutions was rather elegant, actually you can take a look at them at our github repo

One of the solutions really got me thinking though, the one in Erlang (code), when describing how the solution was developed, Phil explained that he knew that argument parsing will be a problem so he created little abstractions that he could test from, once the actual problem of the kata was solved, he dealt with the problem of parsing arguments. What I can’t stop thinking about is, is this type of thinking generated/helped by Erlang and it’s programming model? (Phil’s day job is on Erlang). I had planned to learn Erlang in the not so distant future, I think this question just raised the priority :D.

Anyway, that is all. The next kata meetup is on the 19th of February, I am really excited about it, if you want to come, registration and more info here. We talked about trying to solve a smaller problem, so that we can have more time to show and discuss at the end.

Standing desk day to day

Mon, 20 Jan 2014 12:13:00 +0000

I decided to keep a mini journal with updates about having a standing desk, I figure a lot of people are thinking about it (like I was) and it might be handy to have this information.

Day 1

Today is the first day I am using as standing desk as described in this article . It’s been exciting “building” this.

I used the desk without the shelf for about 4.5 hours two days ago and I was tired (though I had a long run before that, so that might be the reason). I used it without the shelf

Today is officially the first full day and I am finding that having the shelf really helps, also I’m feeling less tension in by upper back than usual. I got this square cushion as well for standing on it (no shoes), and I think it’s more comfortable, compared to standing with runners.

I noticed I tend to shift on my feet at lot, probably that’s good for circulation.

After about 3 hours I sat down for lunch (it felt great)

I’ll update at the end of the day

Had a planning meeting for 3 hours (I was sitting down)

I ended the day pretty tired, the standing aspect stopped me from procastinating a bit

Day 2

I was slightly dreading the idea of coming to work and standing, but when I got here I forgot about it, I was thinking that a new setup like this would take a little while to get used to.

I’m at half day and feeling the legs a bit but not much.

I had to show some code to other people here and it was strange to share the space but it actually was nicer to be standing, it seemed more conducive to a conversation about the code.

End of day, it’s been eight and a half hours and I am pretty tired, I had a few breaks, and sat down. My plan was to do all coding standing and use a laptop for emails and browsing while sitting down, that plan is not working out so far, perhaps I need to try harder (some emails require my immediate attention and I didn’t have the laptop setup there and then). By the way if someone is reading this and have a question feel free to comment or tweet at me @silverspoon

Day 3

I slept like a baby ( I’ also cycling 16 miles a day commuting, I assume that is a contributing factor, however the big change is the standing) I am noticing I am generally in a better mood though.

After 8 hours of work I was really really tired. Sat down, I had trouble staying awake :(

Day 4

Started the day with a lot of energy (and an 8 mile cycle) I’m after the first half and feeling good. I’m noticing my upper-back is really way less tense than normal (ie never noticed how tense I was) also feeling a bit of pain in my lower back, I guess it’s muscle building for standing for longer because it goes away.

Day 5

Nothing new to report really

Week 2

I am halfway through week 2, getting more used to this, I need to learn to take breaks more often. After 8 or 9 hours I am really tired. Benefits I noticed: not upper back pain, higher energy levels

Week 2 Day 3

I had a breakthrough, I think. I am not only able to stand for longer but also I feel higher levels of energy. I would still really like to be able to sit down (particularly when I need to work late,. I also think this is helping my core muscles, but there is no way to measure that so… i.e. be able to revert to normal desk) however I think this experiment is pretty successful. Oh and yes, when people see it they ll ask you about it, so if you are thinking of doing this the first few days everyone asks you about this.

Summary

It’s been a good few weeks now since I started using the desk and this what I think about it

Pros

No upper back pain
better core strength (didn’t measure this because I don’t really know how, suggestions welcome)
Some productivity increase
Easier to show a problem or pair with other people

Cons

Because I have a cheap/fixed standing desk When I am tired I can’t work and sit (I did bring a laptop and remoted into my machine next to me but It felt a bit clunky)
it uses more space than a sitting person (at least on our office)

So basically if I had a standing desk where I can also sit if I want to, that would be amazing =).

XKCD one up-ing :D

The best standing desks

F# Autocomplete plugin for Sublime

Sat, 11 Jan 2014 16:11:00 +0000

I am learning functional programming and the one I am playing with the most is F#. So I was on the look out for something small to do with the language, the other day I saw a tweet from @codebeard where he was asking for some help with a plugin for Sublime for F# Autocomplete, what he has is here.

I started to poke around with it to see if I can make it work. So far:

Find pexpect, I didn’t know what pexpect does. According to the github description it’s a Python module for controlling interactive programs in a pseudo-terminal
I needed the FSharpAutocomplete.exe, so I grab the sources and build, I had to get the F# compiler services package (switch nuget package explorer to pre-release)
In sublime 3, I had to learn about packages and how they work (I always wanted an excuse for this anyway)
After less than an hour I’m pretty much up and running from a setup point of view (I think) but getting an error when I try to build the package, I think it might be the version of pexpect, though the download page said “Pexpect now requires at least Python 2.6 or 3.2.” I have 2.7.5, the error is

*** Error compiling ‘C:\Users\Andrea\AppData\Roaming\Sublime Text 3\Packages\FSharpAutocomplete\lib\pexpect-3.0b1\examples\astat.py’… Traceback (most recent call last): File “X/py_compile.py”, line 121, in compile File “C:\Users\Andrea\AppData\Roaming\Sublime Text 3\Packages\FSharpAutocomplete\lib\pexpect-3.0b1\examples\astat.py”, line 39 print globals()[‘doc’] ^ SyntaxError: invalid syntax

During handling of the above exception, another exception occurred:

Traceback (most recent call last): File “X/compileall.py”, line 115, in compile_file File “X/py_compile.py”, line 125, in compile py_compile.PyCompileError: File “C:\Users\Andrea\AppData\Roaming\Sublime Text 3\Packages\FSharpAutocomplete\lib\pexpect-3.0b1\examples\astat.py”, line 39 print globals()[‘doc’] ^ SyntaxError: invalid syntax

During handling of the above exception, another exception occurred:

Traceback (most recent call last): File “package_control.commands.create_package_command in C:\Users\Andrea\AppData\Roaming\Sublime Text 3\Installed Packages\Package Control.sublime-package”, line 29, in on_done File “package_control.package_manager in C:\Users\Andrea\AppData\Roaming\Sublime Text 3\Installed Packages\Package Control.sublime-package”, line 398, in create_package File “X/compileall.py”, line 61, in compile_dir File “X/compileall.py”, line 61, in compile_dir File “X/compileall.py”, line 61, in compile_dir File “X/compileall.py”, line 56, in compile_dir File “X/compileall.py”, line 122, in compile_file AttributeError: ‘_LogWriter’ object has no attribute ‘encoding’

I updated to python 3.2 and now I’m getting a different error, leaving it here for tonight but will pick it up again as soon as possible.

NOTE: There is one thing that I just realized, if I keep this project this way, it will only work in windows and ideally I would like this to be multi-platform. I need to think about ways to mitigate this.

Yeppp!... for numbers

Sat, 04 Jan 2014 10:13:00 +0000

On the interwebz today I found an interesting library that somehow I haven’t heard of before, and it is a few years old, I wonder if the low popularity level is due to it’s unconventional name: [Yeppp!][yeppp]

What is it?

Yeppp! is a high-performance SIMD-optimized mathematical library for x86, ARM, and MIPS processors on Windows, Android, Mac OS X, and GNU/Linux systems. Yeppp! functions are presented in several versions with optimizations for different processor microarchitectures. During initialization Yeppp! library detects the processor it is running on, and chooses the optimal function implementations. It is also open source with a very friendly commercial licence

one, two, one two

It sounds cool right, so what can we do with this and most importantly is it any good?

There is some graphs and numbers to crunch on the Yeppp website I’m going to be very unortodox(stupid?), not really look at them, and get my hands dirty first.

nice, 100% unit test code coverage
weird, there was no nuget package. Actually the page suggested and msi (why would it need setup scripts mmm)
With the library you get access to a lot of information about cycle stats and architecture information (handy given that the lib is multiplatform) Have a look at the CpuInfo sample

The first thing I did was run the examples, I made some small changes so that the code doesn’t do anything obviosuly non performant (like creating a new instance of Random inside a loop) until I ran into an exception in the Entropy sample… researching. Not a new problem (edit 06-01-2014)

MEF and AppDomains II

Fri, 03 Jan 2014 10:13:00 +0000

Continuing from yesterday, I was testing how hard it is to work with two domains, I found this and it seemed like a good starting place. I started moving things around to understand how it all fits together, and soon I started getting remoting errors… it made me think, I really don’t want remoting problems to be a normal type of problems you get when of developing plugins, however is not a dead option just yet.

When using external dependencies in a composed application you can get a ComposablePartException temporarily I added the dependency to the main project but I am hoping there is a better way to tell MEF about external dependencies that should be “brought in with a type”.

BTW if you are playing with debugging capabilities and related, make sure you have the option “Just my code” in options not selected. If messing with appdomains check that the option for debugging other appDomains is enabled.

Next I am actually trying to integrate this into the project (i.e. where I want this to work) and see what breaks

The convention based stuff in MEF is truly simple. You use a RegistrationBuilder to set what types we are interested in, in my case I wanted to get all types derived from an interface, but I tested with a base class and it worked too, when you are doing that you can create a part builder (as below) and this is where you can set the creation policy which helps when you need to set whether there is one shared instance between many imports or you create one per each importer.

	var classPartBuilder = regBuilder.ForTypesDerivedFrom<MyClass>();
	classBuilder.SetCreationPolicy(CreationPolicy.NonShared);

When you want to get the exports you can use a DirectoryCatalog like this

	var catalog = new AggregateCatalog();
	//PluginRelated is the type where all this code lives
	catalog.Catalogs.Add(new AssemblyCatalog(typeof(PluginRelated).Assembly, _registrationBuilder));
	var directoryCatalog = new DirectoryCatalog(PluginPath, _registrationBuilder);
	catalog.Catalogs.Add(directoryCatalog);

if you want to get the exported types you get a container and compose it

	var container = new CompositionContainer(catalog);
	container.ComposeExportedValue(container);
	var exports = container.GetExportedValues<Component>();

ok, so I hit the dependencies problem, need to read more about this.

MEF and AppDomains

Thu, 02 Jan 2014 16:13:00 +0000

The last few days I’ve been playing with MEF.

MEF is pretty cool, it allows you to recompose your application on the fly so I thought I should try it, I ended up looking at “The Way of MEF”, a series of samples from Glenn Block, pretty good to look at some code and understand what can you do in a clear way. I wish there was a video to go with it because you get the sense that he had a lot to say while those slides were rolling. Anyway, the samples were great,

I think there are better places to learn about MEF, I compiled a bundle of links here, some cool things

MEF is available in .net 4.5 (no dependencies yay!) tho available in other versions of .net
it uses a convention based config if you want (I’m sure a lot of work has gone into it)
With MEF you can deal with unknown types and can fetch new types from a catalog (I tried the assembly catalog only so far)

What I am trying to achieve is to be able to reload new versions of a type on the fly, not only at runtime, at debug time too. The first part is possible within one AppDomain, however not so, the second part (the debuggin part) you can see some code I was trying this with in this github repo (this is really one of the samples from Way of MEF, with a few changes but nothing big). I am sure you are wondering, why, why is it not possible to Debug? Well, it depends :) you can actually debug a little bit but as soon as you start trying to reflect on types you hit the error: “The type <your type> is available in both assembly.dll and assembly.dll” this points to a solution with multiple AppDomains, and I am trying to avoid that.

By the way, in the github sample above I hit a problem, if build, run the exe from the bin/Debug folder while you have the solution open in VS and recompile Bar then the instance will be copied as expected but not updated, if you build from anywhere else (including a different instance of VS) then all is peachy.

I ll report again when I figure what is the impact on my case for multiple AppDomains or if I find an alternative solution.

Moved to Jekyll!

Tue, 31 Dec 2013 23:40:10 +0000

I have moved my blog from wordpress to Jekyll. It was a process a little bit longer than I expected and I am not done with it, but I’m glad to have started the process.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo.

2013 in review and moving on

Tue, 31 Dec 2013 14:37:32 +0000

The WordPress.com stats helper monkeys prepared a 2013 annual report for this blog.

Here’s an excerpt:

The concert hall at the Sydney Opera House holds 2,700 people. This blog was viewed about 31,000 times in 2013. If it were a concert at Sydney Opera House, it would take about 11 sold-out performances for that many people to see it.

Click here to see the complete report.

I’m moving the blog over to github, the transition involves more steps than I would like, but still I think it will be worth it. If you want to see how it’s going check here, this blog at roundcrisis.wordpress.com will stay live until the transition is complete.

Happy new year!!

Multithreaded game engine -Using Concurrent collections instead

Sat, 22 Jun 2013 21:40:10 +0000

So, while I was trying to implement the double buffer (previous post available here) I started thinking about perhaps a simpler implementation with one of the concurrent collections, so I tried with a ConcurrentQueue<T>.

The idea behind it is pretty simple. Instead of having the two collections of RenderCommand we have a ConcurrentQueue<RenderCommand[]> so we think of each of the elements of the queue as a frame, ready to be rendered.

As before, we are starting off with the primitives3DWindows sample. A bit obvious, but, we’ll need to initialize the queue on the constructor of the Renderer class(I just thought I’d mention that).

From the world We’ll add all necessary cubes to a renderCommand, using the AddCube() method. At the end, we’ll need to add that collection to the queue by calling EndFrame(). Like this

public void AddCube(Cube primitive)
{
    var translation = Matrix.CreateFromYawPitchRoll(
        primitive.Rotation.X, primitive.Rotation.Y, primitive.Rotation.Z) * 
        Matrix.CreateTranslation(primitive.Position);
    _updatingRenderCommands.Add(new RenderCommand
                                    {
                                        Color = primitive.Color, 
                                        Radius = primitive.Radius, 
                                        World = translation
                                    });
}
 
public void EndFrame()
{
    var renderCommands = new RenderCommand[_updatingRenderCommands.Count];
    _updatingRenderCommands.CopyTo(renderCommands, 0);
    _concurrentRenderCommandsThatRepresentAFrame.Enqueue(renderCommands);
    _updatingRenderCommands.Clear();
}

These methods are public because they are called from World, however, as you can see from the sequence diagram below we check if the renderer CanAcceptCommands(), the reason for this is that we don’t regulate how often we run world.Update() and in reality we only want to have one frame (or RenderCommand collection ready to render) when we call Draw so that there is no latency.

With the update done, we now need to render. At this point this is pretty trivial. Code below

public void Draw(Matrix view, Matrix projection)
{
    RenderCommand[] renderCommands;
    if (!_concurrentRenderCommandsThatRepresentAFrame.TryDequeue(out renderCommands))
        return;
 
    foreach (var renderingRenderCommand in renderCommands)
    {
        _cubePrimitive.Draw(
                              renderingRenderCommand.World, 
                              view, 
                              projection, 
                              renderingRenderCommand.Color);
    }
}

I think what is happening here is pretty self explanatory, but I will do it anyway. If we call Draw() and we TryDequeue and we can’t we call return, there is no point in trying to Draw and empty array of RenderCommands (I believe that would be the result). Alternatively if we successfully dequeue, we will let the CubePrimitive draw each of the commands.

Analysis

It seems to me that this implementation is easier to follow and implement that the previous one, however I took some performance data and this is the result:

Double Buffer

Concurrent Queue

Green means execution time, and red means synchronization time.

I think what these graphs tell is that double buffer is more efficient because concurrentqueue uses spin waits to synchronize, so it shows up in the thread analysis as execution time, where the previous double buffer implementation shows up as synchronization time, meaning the threads are just asleep.

Next I’m going to try with a concurrent collection that doesn’t use spin wait: BlockingCollection<T>.

Multithreading rendering in a game engine with C# - Double buffer implementation

Fri, 24 May 2013 12:40:10 +0000

A game running at 60FPS needs to render every 16 milliseconds, meaning that all the logic for collision detection, animation, obstacle avoidance, physics, etc. must happen in that very short time. You also need to prepare for rendering and then send the instructions to the GPU. Multithreading see ms like a most reasonable option if you have more than one core available (and who doesn’t these days).

One of the ways to do multithreading rendering in games is using a double buffer. At a high level the concept is simple: given two threads update and render, use one to fill a buffer with commands that have enough info to render(we’ll call them RenderCommands), once completed switch buffers while the other thread renders the RenderCommands in the original buffer.

Graph and possibly a better explanation of double buffer from http://bit.ly/110JuB3

You might be wondering what is a render command, well it’s the smallest amount of information we need to send to the GPU so that it can render what we want it to render. A Render command for a cube only engine (ie our engine can only draw cubes) can be as simple as:

 public class RenderCommand
{
    public float Radius { get; set; }
    public Color Color { get; set; }
    public Matrix World { get; set; }
}

There are many ways to implement this double buffer technique. The implementation we are going to see in this example is based on Quake 3 source code using modern C# to implement it. Questions, comments and optimizations welcome :D. By the way, a really in-depth review of the code is available here.

The idea

The update thread is the red one and the render thread is the blue one.

The diagram above describes the flow of the update thread(red) and rendering thread(blue), the hatched squares represent blocking.

At the initial stage, the render thread will be waiting for the render commands to become available, it will be signalled from the update thread. Once that happens, the render thread will swap the buffers, signal to the update thread that the commands have swapped and that the render thread is ready to start drawing and start drawing.

This signalling process works well also for the situation when the update frame takes longer to update and the render thread needs to wait for the render commands to become available.

Finally the situation where rendering takes longer is also covered, as we see in the the update thread is waiting until rendering is finished

The implementation

For the purposes of this example we will be using XNA. To have something to show and compare against, I’m starting off with the 3d primitives sample from XNA Creators code club.

I am going to skip the details about how to draw vertices, there are many other blog posts that cover that and focus on the threading and concurrency issues.

So, for a start we need to create the update thread. To that effect we will instantiate a class called UpdateLoop in a Task that will simply loop on executing Update as follows.

 Task.Factory.StartNew(() = 
{
        var gl = new UpdateLoop(_renderer);
        gl.Loop();
});

The loop in UpdateLoop: (Note: the loop is not time stepped, ie you should not use a while(true) like this in production).

public void Loop()
{
    _stopwatch.Start();
    while (true)
    {
        Update();
    }
}

The code for the loop is (i think) pretty self explanatory, when calling Update in line 5 it will follow the sequence as described in diagram below.

It is probably interesting to see what AddCube() looks like :

public void AddCube(Cube primitive)
{
    var translation = Matrix.CreateFromYawPitchRoll(
                            primitive.Rotation.X, 
                            primitive.Rotation.Y, 
                            primitive.Rotation.Z) *
            Matrix.CreateTranslation(primitive.Position);
 
    _updatingRenderCommands.Add(
        new RenderCommand
                {
                    Color = primitive.Color, 
                    Radius = primitive.Radius, 
                    World = translation
                });
}

As you can see from the sequence diagram, after looping on renderer.AddCube() there is a call to renderer.EndFrame(), here is where we need to signal that the render commands are ready and the update thread will be now waiting for the render buffers to be swapped.

 public void EndFrame() { 
 	_renderCompleted.WaitOne(); 
 	_renderComandsReady.Set(); 
 	_renderActive.WaitOne(); 
 }

From the render thread point of view, this is what the sequence diagram looks like:

In my game class (the main class that inherits from XNA’s game class) , in Draw(), we call _renderer.Draw():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  public void Draw(GraphicsDevice device, Matrix view, Matrix projection)
{
    _renderActive.Reset();
    _renderCompleted.Set();
    _renderComandsReady.WaitOne();
 
    _renderCompleted.Reset();
    _renderComandsReady.Reset();
    SwapBuffers();
    _renderActive.Set();
 
    _cubePrimitive = _cubePrimitive ?? new CubePrimitive(device);
    foreach (var renderingRenderCommand in _renderingRenderCommands)
    {
        _cubePrimitive.Draw(renderingRenderCommand.World, 
                                    view, 
                                    projection, 
                                    renderingRenderCommand.Color
                                    );
    }
}

This is probably the most complex method in the whole example. The _renderActive is reset because at this point we want the update thread to block when on wait, this was set to wait from _renderer.EndFrame(). We set _renderCompleted here to unblock the update thread and then we wait for _renderCommandsReady to be signalled, effectively putting the renderer to sleep until there are more commands to render.

Before calling SwapBuffers() _renderCompleted is reset so that if the update thread reaches the end of a frame, it will sleep until the render thread has finished swapping the buffers.

Immediately after, a call to reset _renderCommandsReady ensures that the render thread will go to sleep on the next Draw call until there are some commands to render.

I am not terribly sure the explanation above is clearer than the actual code to be honest, but after 4 6 attempts I’m giving up.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  private void SwapBuffers()
{
     
    if (_updatingRenderCommands == _bufferedRenderCommandsA)
    {
        _updatingRenderCommands = _bufferedRenderCommandsB;
        _renderingRenderCommands = _bufferedRenderCommandsA;
 
    }
    else if (_updatingRenderCommands == _bufferedRenderCommandsB)
    {
        _updatingRenderCommands = _bufferedRenderCommandsA;
        _renderingRenderCommands = _bufferedRenderCommandsB;
    }
    _updatingRenderCommands.Clear();
}

Finally SwapBuffers(). There’s no synchronization happening here so, we are just switching buffers. Before calling this method the _renderComandsReady was blocked

And that is pretty much all, the complete sample is available from github .

References and interesting related articles

Most excellent Quake 3 code review http://fabiensanglard.net/quake3/index.php

Threading your game loop http://www.altdevblogaday.com/2011/07/03/threading-and-your-game-loop/

For the craic http://en.wikipedia.org/wiki/Multiple_buffering

The dying platform: .Net

Wed, 15 May 2013 10:40:10 +0000

For the last few years I have been writing code in C#. I think C# and .net are great tools to write software. I find that C# is exactly where I need it to be, I can do low level when I need to work with pretty high level abstraction (ish). However the world (unfortunately) doesn’t do what I want and it feels like the momentum .net had is certainty fading.

These are some reasons why I think this is happening (not all related directly to programing)

Inherent hatred for Microsoft and anything it does, even if it is good. I think is pretty sad since I see this attitude from people that should be objective from a technical standpoint, licensing can’t always be an issue.
Windows 8 and WinRT with it’s confusing .net support. It doesn’t help when it comes to .net developers either. It seems like their intention was to bring in the “cool kids(?)” but with that they alienated the people that supported them.
All the windows phones, and particularly the WP7 fail (no update path for win 8). It is fail from a commercial standpoint and from developer support, how can you spend any significant amount of time with a platform that you don’t know is going to be there in a year or if there is any support for it.
Half arsed open sourcing, by this I mean, you can read the code but no thanks, we don’t take pull requests Sad smile.Also, the very common not invented here that MS keeps doing (Monorail vs MVC, Nunit vs MStest, NHibernate vs EF, and many others ).
Tablets and the fact that MS doesn’t have a significant share on any of this, so for many the digital experience is via apple or android.
For me, killing XNA. A great SDK, suddenly abandoned. Why? no one ever gave a reason I can remember (can you?)
XBOX vnext rumoured online only putting a nail on the XBOX coffin.

What could save it (maybe)

Strangely, Xamarin because of their amazing mobile tools based on mono . Unity helps too, but I do wonder about what they have in mind for the future
Aliens?

Edit: Maybe F#?

More Mono for android (Xamarin.Android) little tips.

Fri, 15 Mar 2013 16:22:57 +0000

Mono for android or Xamarin.Android little tips:

If you turn on GPU emulation, sometimes GPU emulation doesn’t actually start, it downgrades to software rendering, this makes the emulator slower and it doesn’t actually uses OpenGL(if you are using monogame, this means your game would probably not work).
If you are looking for a grid like component that stretches with a fix number of grids, I couldn’t find one. Had to write my own and the code is ugly .
You can use ScreenOrientation = ScreenOrientation.Portrait as an attribute in your activity and ConfigurationChanges = ConfigChanges.Orientation is also an activity attribute that prevents the activity from restarting when orientation changes.

Xamarin just announced support for C# 5 features in the mobiles suites, very exciting news… more details here.

Tomorrow, post about monogame stuff.

Monogame presentation at #gig2013 and #gamesFleadh

Fri, 15 Mar 2013 16:06:25 +0000

I did a few presentations about Monogame in Gaming Reimagined (at what used to be the Landsdowne Road Stadium) and in Games Fleadh, if you were there I would really appreciate your feedback (good and bad, please just leave a comment here).

The slides are available here. I will make the code available soon and update this post. There is a video for it here

During both events there was some pretty cool talks. About both the industry and making games.

During Games Fleadh I Particularly enjoyed listening to Steve Ewart from Havok showcase his many cool demos and the guys from DemonWare talk about their experiences in their company and it some of the big games studios.

Kudos to the organizers of both events and Congratulations to all the award winners of Games Fleadh awards: bitsmith got Best Games and an awesome tank.

Pic from Bryan Duggan (https://www.facebook.com/media/set/?set=a.423888310976750.1073741831.113468182018766&type=1)

Mono for Android - Beyond getting started

Sun, 24 Feb 2013 12:18:10 +0000

A few weeks ago I bit the bullet and bought Mono for Android. I also decided to update to all devices to Ice Cream Sandwich as the UI is just so much better. Should have done that ages ago, but I was just afraid Kies would brick my phone again.

Anyway, the new features that I’m sure anyone interested in android development already know about: Services, fragments, new UI. Cool stuff, it also meant a lot to learn .

Some things that you might want to try out if you are starting this out:

Preferably have a device or two , the emulator is slow. The x86 emulator is an interesting option, it didn’t work for me initially but then I tried a few different virtual devices and then you could really see the benefits… way faster. Still is good to deploy to the phone often enough.
Since android 3.0 there is a new way to do drag drop that works as a state machine. More info in the excellent Jeremie Laval’s blog. Check the other posts, they are really cool too.
Fragments are trickier to deal with that I thought. Pretty sure I’m doing something wrong (as all times you start learning something new) but I wanted to replace a fragment (with UI elements on it) with another fragment (also with UI elements on it) however if the first fragment was placed there with the layout xml and the second one programmatically, It just didn’t work. It did work when both where placed programmatically. Any hints on this would be great.
To use the Holo Theme across your app, simply add this snipet to your manifest to your manifest. More on styles here.

One to check out… there is an android unit test suite Andr.unit (github repo)a unit testing framework for android based on Touch.Unit.

A build system for games

Mon, 28 Jan 2013 23:22:02 +0000

As you might or might not know, I am one of the founders of BatCat Games, the important word about that sentence is **games. **The fact that we make games put a series of differences into our production that doesn’t generally affect non game software development cycles.

For a start art and animation are key in a game, so are visual effects. In build server terms, that generally means two things: It requires space(for content building) and quite probably a graphics card (for the visual effects). Our ideal solution would be to have a virtual machine per supported platform , but we found that none of the virtualization software (VirtualBox, VMWare, etc) virtualizes the graphics card reliably (if you found a way, please let me know) so we are running our server on a non virtual machine.

The objective is to build the whole game, tools, etc. at each commit. There are a series of tools available in the market at the moment that allows you to do just that. For example: TeamCity, Jenkins, CruiseControl, Hudson.. etc. There is a good comparison matrix here.

We chose TeamCity, mostly because we know it, we find it easy to use and it is free.

Our setup

Our code is based around XNA and monoGame (recently on version 3).

We have many projects: a game and engine project, a tool, a library and the content builder. This means we have a diverse project output. For example, in the case of the content, we are not interested in the actual build results (yet) however we are interested in knowing that it did build, and to report errors if it didn’t.

The game and engine project reside in one solution and have many unit tests. We need the build server to not only build the project and after that run the unit and integration tests. Initially I set this up using psake (a tool that does the build with PowerShell) this is a great solution if you want to have a one click build, so I gave it a try, I found that setting up the tests assemblies was a manual process and that to get psake to talk to TeamCity nicely it would take more time that I had. So I tried running the build directly from TeamCity, and it was easier and I didn’t loose to much flexibility so, I had to go for that solution (however is a decision I will revisit shortly).

Setting up each of the steps took me approximately 10~20 minutes if done this way. There are a few things that I want to improve on, however the end result is that in a very short time I can have a new project building and reporting.

Some of the disadvantages of the process as it is are:

If I want to change the build type I need to do it manually, in this case, the target test assemblies will need to be updated
At the moment we are using dropbox as our way to distribute the builds, it is a process some members of our team really like because they just get the new binaries and they can choose when to update (so that there is no friction). I would prefer if the tools would just auto-update, but this is working for the moment.

Summary

As you can see the server setup is not perfect, there is loads to improve on, but setting this up from early on has proven very helpful. It allows us to have a one click build and a functional way to deliver our tools and product to the people in our team.

Note: This post was cross posted to gamasutra, Thanks to Kris for her help.

Mono for android

Sat, 12 Jan 2013 13:24:15 +0000

I’ve been playing with mono for android the last few days. I have also tried it about 2 years ago. It was a good tool then, and it got much much better.

Getting started is pretty simple, you download the installer, install. It will install all prerequisites for you on your machine. Allegedly this failed the first time but worked the second time, I had a log to look at to give me some idea of the problem.

Once I got set up I started reading the documentation. Not only it was in place, but also, it was written to the right level (i.e. assumes you are a smart individual), I then moved on to pricing, 400 usd ouch, but I will come back to this. If you don’t activate the product you can test on the emulator. It gives you some sort of idea of what the experience is like. The emulator is slow, and brittle, but that is something we should talk to Google about.

At this point I started going over some tutorials, using both monodevelop and VS just for the fun of it. The main thing I miss from VS when I’m in monodevelop is resharper . I had no real troubles getting on with creating a little app (a games reviews collector) .

I went ahead and bought the license, activated and pushed to the device and it is much faster than using the emulator.

One gotcha was that I wanted to write files and then be able to access them via USB, I kept getting a file permission error, I needed to set up the permission on the manifest file, it wasn’t obvious to me, but that is ok. All the information I needed was here.

Deployment to other devices is also pretty simple, you build the app on release mode and use the *-Signed.apk, there are other ways to deploy here.

Mostly the reason for this blog post is that I was a bit surprised with how good an experience it was (so far) .

Next I will be working with some eventually connected storage, I heard good things about Parse.

I gave myself a pomodoro to finish this post, so I’ll have to talk about pricing in tools some other time .

Till the next time

DirectoryTruncator - Update II

Sun, 30 Dec 2012 22:33:03 +0000

So, after the last post, where I introduced Directory truncator, I present you some extra work I have just committed. My plans for it from the previous post where

Logging and or console output so you know what happened, I couldn’t so far decide on what is the best approach or if I want to choose one, so I ll do that tomorrow .
On error, proceed to the next file/folder.
Have a StartsWith parameter(on both methods), so that it only deletes files or directory that start with
Turn it into a service

So, this is what happened,

After thinking a little bit about it, I just went for NLog, it does what I need it to do for the moment. Logs need no test, so I added a few log messages, there is probably some log messages missing.
For this one, I ended up making a decision I’m still mulling over. I needed to test that if there is an error on file delete, the process will log and keep going. How to do that? well, I created a thin wrapper around the file system, as far as I could see it, there was no other way to simulate the scenario of you have two files to delete and one of them is deleted before we get to it. I have yet to do this for TruncateByDirectory.

This is all for today, and since this is probably the last post of the year. Merry New Year!!!

Directory Truncator

Thu, 27 Dec 2012 14:45:06 +0000

Recently I needed some code to truncate a directory of files or folders, for example I wanted to remove files or directories given a max number of files or directories. This is a common task when you have backups and you don’t want every single backup since forever, but you want to keep the last 5 ones. Another common scenario is when you have builds and you only probably want the last 10 (particularly if your build is used only by 4 people that seat across from you).

Anyhow, I have written similar code in the past and I know I will probably need something that does the same thing in the future, so I created a super small library and I put it on github.

I think the tests explain better what the code does than I do. So have a look.

There are a few things that I want to add to this project

Logging and or console output so you know what happened, I couldnt so far decide on what is the best approach or if I want to choose one, so I ll do that tomorrow .
On error, proceed to the next file/folder.
Have a StartsWith parameter(on both methods), so that it only deletes files or directory that start with
Turn it into a service

There are probably more things that could be done with it, but honestly, that is all I need.

Comments, questions or any feedback welcome!

Note: The image above is totally unrelated but I found it looking for truncated. What I found interesting about it is that the article this image relates to is about the Wearie-Phelan structure, this structure inspired the Beijing National Aquatics Centre and other cool stuff you can read here.

Happy holidays

XNA PSD ContentProcessor

Tue, 11 Sep 2012 15:34:53 +0000

I needed a psd content processor and found one here it is based on the EndoEngine. The one available depended on XNA 3.1, I did some clean up on the project and made it available via my account on github.

We (at BatCat Games) are working on a Content hot loader that will be available open source soon (at the moment it doesn’t really work ) it will probably include this content processor.

The code comes with a sample game that displays a Photoshop file as a texture.

Fail to add a sprite to XNA content project

Mon, 06 Aug 2012 10:05:53 +0000

This is not a big one but it’s good to know.

I was spiking a little thing in a new XNA 4.0 game project and then attempting to include a png into the content folder, the file was there, I could see it (using show all files menu) but when using the context menu “Include in project” nothing was happening. Why?

First I thought maybe the file type is not supported, but PNGs are. Then someone pointed out, is this a project on a Reach Profile? textures larger than 2048 are not supported, this was a large sprite-sheet. So, I changed the profile of the project and I was able to Include the file.

Happy Monday

Reading Diary: Real World Functional Programming - Day 2

Mon, 23 Jul 2012 16:32:06 +0000

A reading diary is my way to discuss with myself what I think about the book as I read it. It probably has errors of different kinds.

Some notes on the remaining of Chapter 1

F# intro, how its mostly functional but supports some OO features
How C# incorporates functional ideas.
Reading about declarative programming, these made no sense
- Definition of declarative programming style. Logic without the details… mmm ok lets see how this goes
- Functional means not only we can add new commands but also new structures
Code, finally a code example came about and it was all cleared up
Concurrency friendly application design, I was expecting the how but I got a birds eye. Patience
The section on how functional style shapes your code is cool, as it details how your code will (hopefully) slowly change. It highlights
- the fact that OO design is still useful,
- it helps simplifying some patterns
- make the code more readable (this I’m not so sure about, I’ve read code from people who started learning functional programming and on my view the code was less readable and harder to follow, particularly on tests)
Section 1.4 is all example based. Not mad about the fact they used WPF for one of them(not a fan), but no biggie, it gets the point across anyway . The author obviously wanted the reader to understand what declarative and imperative means and understand the difference
I can start to see how this style of programming could be really beneficial
Got as far as the recursion samples with C# (2.2.3)

That’s all for today. It’s been hard to find time to read up on this.

Reading Diary: Real World Functional Programming - Day 1

Sat, 16 Jun 2012 09:15:31 +0000

I‘ve been feeling that I’m missing out by not knowing much about functional programming and this book was recommended to my many times, so I started reading it.

Expectation

I expect to learn more about functional programming, I would like to be able to translate the ideas to other functional programming languages.

Objective

I would like to be able to use functional programming ideas day to day on game development, there is a lot of asynchronous flow control in games that I hope, can be improved. The problem with this is that features that are ok to use in other types of development, such as LINQ, don’t perform well enough on game development, at least that’s what the performance analysis was showing us in some sectors of the code.

I think this objective is perhaps overly optimistic, the world would be too boring for me if I set myself reachable goals all the time, right?

Intro and part of Chapter 1

Going over some basic functional ideas, but I’m already feeling I should have read this book earlier. Some comments as I go along:

There are some parts of the chapter where I feel like the author is trying to sell me the idea, I can understand why, but I’m already reading the book, no need for that.
I like the way important concepts are highlighted
Well written, ideas are exposed in a super clear way
No point in reading this book in a hurry, If I don’t fully get an idea, I can’t afford to move on

Leaving it here for today …

Raven DB: Day to day at #DDDSW

Tue, 29 May 2012 09:13:00 +0000

So I was at DDD South west last saturday presenting Raven DB: day to day.

The day flew by with great presentations. I got to see:

Performance and Scalability, the Stack Exchange way by Marc Gravell . I have to admit I didn’t expect that much SQL on the presentation but interesting nonetheless, would really like to hear him talk more about how they use Redis and SQL together more. Also when he started talking about serialization we ran out of time :( There was a lot of questions and Marc did a great job at answering them.
StyleCop – Breaking down the barriers to entry by Gary Park . Really well presented, and a few interesting details about team city and other extensions.
Raven DB: day to day, by me :D I’m probably the worse person to judge how this went, from my side of things, I heard you guys laugh and ask questions, in my books, that is pretty ok. Feedback from people always great ( Phil Thanks for yours already)
During lunch I wanted to go to the grok talks however I ended up catching some sun and a really interesting chat with Matt (he contributes to RavenDB , trying to convince the man he should really write some posts about facets )
WebSockets and SignalR - Building the real-time, multi-user interactive web by Chris Alcock. I haven’t played yet with SignalR yet so it was good to see this, I kinda knew what to expect tho. Well presented
NoSql Document Databases: Why would you want to use one? by Ian Russell, Great intro to NoSQL, really liked Ian relaxed approach to questions. Great session

Just in case anyone is interested, my slides for the talk. Thanks to all attendees and organizers for a great weekend

[slideshare id=13115644&doc=ravendb-120529033908-phpapp01]

Busy May with RavenDB

Wed, 16 May 2012 10:17:23 +0000

Just a small post to let you know. I’ll be speaking in two conferences this month.

The 26th of May at DDD South West. The topic is Raven DB Day to Day

Closely followed by an Introduction to Raven DB in Progressive.net (London) the 31st of May

If there is a particular topic you want to see there, please let me know

Cheers

XNA - A Simple Spring Camera in 2D

Sat, 05 May 2012 14:10:29 +0000

Cameras are cool, so lets keep at it and try a spring camera, i.e. one that follows you around.

The initial aspect of the camera and how to use it is on the previous post on cameras, so I ll let you go and have a look there.

The spring camera is very similar to a simple camera, but with Hooke’s Law applied. Hooke’s Law states that the extension of a helical spring is directly proportional to the weight applied, provided the elastic limit of the spring is not exceeded. I read this a few times and couldnt figure how to turn this into code , so I went to Khan Academy and found this video, where the formula F = –k x is explained.

[youtube=http://www.youtube.com/watch?feature=player_embedded&v=ZzwuHS9ldbY]

If we use the formula as is, then the spring would be “springing” forever, so when calculating the force we will use some damping. So the new update method in Camera.cs now looks like this

<span style="color:#606060;" id="lnum1"> 1:</span> <span style="color:#0000ff;">public</span> <span style="color:#0000ff;">void</span> Update(<span style="color:#0000ff;">float</span> elapsedSeconds, <span style="color:#0000ff;">float</span> rotation, Vector2 desiredPosition, <span style="color:#0000ff;">float</span> zoom)

<span style="color:#606060;" id="lnum2"> 2:</span>     {

<span style="color:#606060;" id="lnum3"> 3:</span>         var delta = _position - desiredPosition;

<span style="color:#606060;" id="lnum4"> 4:</span>         var force = -SpringStiffness * delta - Damping * _velocity;

<span style="color:#606060;" id="lnum5"> 5:</span>

<span style="color:#606060;" id="lnum6"> 6:</span>         var acceleration = force / Mass;

<span style="color:#606060;" id="lnum7"> 7:</span>         _velocity += acceleration * elapsedSeconds;

<span style="color:#606060;" id="lnum8"> 8:</span>         _position += _velocity * elapsedSeconds;

<span style="color:#606060;" id="lnum9"> 9:</span>

<span style="color:#606060;" id="lnum10"> 10:</span>         Transform = Matrix.CreateTranslation(-_position.X, -_position.Y, 0) *

<span style="color:#606060;" id="lnum11"> 11:</span>                     Matrix.CreateRotationZ(rotation) *

<span style="color:#606060;" id="lnum12"> 12:</span>                     Matrix.CreateScale(zoom, zoom, 1)*

<span style="color:#606060;" id="lnum13"> 13:</span>                     Matrix.CreateTranslation(_halfScreenSize.X, _halfScreenSize.Y, 0);

<span style="color:#606060;" id="lnum14"> 14:</span>     }

The line

var force = -SpringStiffness * delta - Damping * _velocity;

Is respecting the formula F= –kx, where k is the SpringStiffness and x is the delta(in orange). The second part of this assignment(in green) is applying some damping proportional to the velocity.

Once we have the result of calculating the force, we use the force vector to calculate the acceleration that, in turn that value is used to calculate the velocity and position.

Finally, once we have the position, the matrix transformation is calculated in the same way we calculated this for the simple camera (in previous post).

You can get a complete working sample here.

Using Mercury Particle Engine with Windows Phone 7

Sun, 29 Apr 2012 17:46:18 +0000

This a very simple walk through to use Mercury on a Windows Phone 7 project.

Get the binaries

As far as I can see, Mercury supports Windows Phone 7 only in version 4.0, if you go to the project page you _wont _find this on downloads, as it’s not yet released.

So, you have to get the sources from here and build the project and find the correct binaries. An alternative is to download them from here (I forked the repo and added the binary download for WP7 ) If you ask nicely I’ll add all the other binaries.

Once you have the binaries, include ProjectMercury.dll in the project where you want to use the particle engine, and add ProjectMercury.ContentPipeline.dll to the content project.

Code

I am not entirely sure where is the best place for the initialization code, you can probably place it in LoadContent, tho I did create the new instance of SpriteBatchRenderer in the constructor of my game class.

<span style="color:#606060;" id="lnum1"> 1:</span> <span style="color:#008000;">// It needs the GraphicsDeviceManager</span>

<span style="color:#606060;" id="lnum2"> 2:</span> _spriteBatchRenderer = <span style="color:#0000ff;">new</span> SpriteBatchRenderer{ GraphicsDeviceService = _graphics };

<span style="color:#606060;" id="lnum3"> 3:</span>

<span style="color:#606060;" id="lnum4"> 4:</span> _particleEffect = Content.Load<ParticleEffect>(<span style="color:#006080;">"Demo1"</span>);

<span style="color:#606060;" id="lnum5"> 5:</span>

<span style="color:#606060;" id="lnum6"> 6:</span>             <span style="color:#0000ff;">foreach</span> (var emitter <span style="color:#0000ff;">in</span> _particleEffect.Emitters)

<span style="color:#606060;" id="lnum7"> 7:</span>             {

<span style="color:#606060;" id="lnum8"> 8:</span>                 emitter.ParticleTexture = Content.Load<Texture2D>(<span style="color:#006080;">"Star"</span>);

<span style="color:#606060;" id="lnum9"> 9:</span>                 emitter.Initialise();

<span style="color:#606060;" id="lnum10"> 10:</span>             }

<span style="color:#606060;" id="lnum11"> 11:</span>             _spriteBatchRenderer.LoadContent(Content);

All you are doing is loading the particle effect through the content pipeline. Then you are iterating over the emitters in the effect to assign the ParticleTexture value, ie a texture you just loaded, and initializing each of the emitters. Finally you need to call LoadContent, calling this method is required because it creates the internal SpriteBatch instance* .

In the update you will need to call

<span style="color:#606060;" id="lnum1"> 1:</span> <span style="color:#008000;">//position is a Vector3</span>

<span style="color:#606060;" id="lnum2"> 2:</span> _particleEffect.Trigger(<span style="color:#0000ff;">ref</span> position);

<span style="color:#606060;" id="lnum3"> 3:</span> _particleEffect.Update((<span style="color:#0000ff;">float</span>) gameTime.ElapsedGameTime.TotalSeconds);

You need to Trigger the particle with a position (there are a number of overloads for this method, make sure you check this out) and then Update. If you fail to do either of those calls, no particles will be rendered.

Finally in the Draw function:

<span style="color:#606060;" id="lnum1"> 1:</span> var matrix = Matrix.Identity;

<span style="color:#606060;" id="lnum2"> 2:</span> var cameraPosition = Vector3.Zero;

<span style="color:#606060;" id="lnum3"> 3:</span> _spriteBatchRenderer.Transformation = Matrix.Identity;

<span style="color:#606060;" id="lnum4"> 4:</span> _spriteBatchRenderer.RenderEffect(_particleEffect, <span style="color:#0000ff;">ref</span> matrix, <span style="color:#0000ff;">ref</span> matrix, <span style="color:#0000ff;">ref</span> matrix, <span style="color:#0000ff;">ref</span> cameraPosition);

Please find a full working sample here

And this would be what you see when you run the project

Some thoughts

I have to admit, I find it strange that the constructor for SpriteBatchRenderer doesn’t require GraphicsDeviceManager, and instead you need to initialize the property, if you don’t set this property before you call LoadContent, then you get a NullReferenceException, as this is where the internal instance of SpriteBatch is created and a GraphicsDevice is required.

My suggestion here would be to have two versions of the constructors, one where you pass the reference of spriteBatch you have, and another one where you pass the instance of GraphicsDevice, as all usages point to only actually consuming that.

These are just some thoughts on the API, and there might be really good reasons for the decisions made this way that I don’t know about. I think that all in all this is a great project, thanks to the creators and maintainers of it.

XNA - A Simple 2D Camera

Thu, 19 Apr 2012 15:21:10 +0000

What is a camera? Intuitively we know what a camera is: simply a way to show the action.

A Camera allows us to deal with the display of the action in a detached way from the action.

Implementation

I like to start with what we are trying to achieve. For the purposes of this post, I want to have two cameras showing the same action at different zoom levels, like this:

In this case we want 2 cameras, with each camera having it’s own ViewPort that we assign when creating like this:

<span class="kwrd">int</span> halfScreenWidth = GraphicsDevice.Viewport.Width/2;
_camera1 = <span class="kwrd">new</span> Camera(<span class="kwrd">new</span> Viewport(0, 0, halfScreenWidth - 3, GraphicsDevice.Viewport.Height));

What we are saying with that is that the Camera class will have a Viewport that occupies the left side of the screen. The - 3 is there to add a visible gap between the left and right sides of the screen. Lets look at the following portion of the Draw method. Please note you could have all the parameters for _spriteBatch.Begin() null, except for the transform.

<span class="lnum"> 1: </span>            GraphicsDevice.Viewport = _camera1.Viewport;
<span class="lnum"> 2: </span>

<span class="lnum"> 3: </span>            _spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullNone, <span class="kwrd">null</span>, _camera1.Transform);
<span class="lnum"> 4: </span>            _level.Draw(_spriteBatch);

<span class="lnum"> 5: </span>            _spriteBatch.Draw(_tankTexture, _tankPosition, <span class="kwrd">null</span>, Color.White, _rotation, <span class="kwrd">new</span> Vector2(_tankTexture.Width / 2, _tankTexture.Height / 2), 1, SpriteEffects.None, 0);
<span class="lnum"> 6: </span>            _spriteBatch.End();

Since we have a viewport per camera, the graphics device needs to know which one to use, and that’s what we are doing in line 1 in the code above. The other important part of the code is the last parameter of the _spriteBatch.Begin call, where we are using the transformation matrix from the camera. This transform is calculated on each update.

So finally lets look at the Camera class:

<span class="lnum"> 1: </span>    <span class="kwrd">public</span> <span class="kwrd">class</span> Camera

<span class="lnum"> 2: </span>    {

<span class="lnum"> 3: </span>        <span class="kwrd">public</span> Matrix Transform { get; <span class="kwrd">private</span> set; }

<span class="lnum"> 4: </span>        <span class="kwrd">public</span> Viewport Viewport { get; <span class="kwrd">private</span> set; }

<span class="lnum"> 5: </span>

<span class="lnum"> 6: </span>        <span class="kwrd">public</span> Camera(Viewport viewport)

<span class="lnum"> 7: </span>        {

<span class="lnum"> 8: </span>            Transform = Matrix.Identity;

<span class="lnum"> 9: </span>            Viewport = viewport;

<span class="lnum"> 10: </span>        }

<span class="lnum"> 11: </span>

<span class="lnum"> 12: </span>        <span class="kwrd">public</span> <span class="kwrd">void</span> Update(GameTime gameTime, <span class="kwrd">float</span> rotation, Vector2 position, <span class="kwrd">float</span> zoom)

<span class="lnum"> 13: </span>        {

<span class="lnum"> 14: </span>            Transform = Matrix.CreateTranslation(-position.X, -position.Y, 0) *

<span class="lnum"> 15: </span>                        Matrix.CreateRotationZ(rotation) *

<span class="lnum"> 16: </span>                        Matrix.CreateScale(<span class="kwrd">new</span> Vector3(zoom, zoom, 1)) *

<span class="lnum"> 17: </span>                        Matrix.CreateTranslation(Viewport.Width / 2, Viewport.Height / 2, 0);

<span class="lnum"> 18: </span>        }

<span class="lnum"> 19: </span>    }

The least obvious part of this code lies in the matrix transformation. It is important to understand that we have two coordinate systems in place, the screen and the world. With the transformation matrix we are trying to project the world coordinate system onto the screen system. With that in mind, the first translation matrix (line 14 in the code above) will reposition the world so that point (position.X, position.Y) lines up with the screen’s origin. The result is as follows:

What you see at the top left of the pic is a quarter of the tank. If you change the tank’s position then you will see that the tank remains static at the top left (tho rotation applies) and the world moves underneath it.

The next line, Matrix.CreateRotationZ, creates a matrix representing a rotation around the Z axis. The Z axis points straight out of the screen. In 2D, to perform a rotation, we always rotate around Z.

Then we need to scale, using the parameters that we sent on update. Don’t forget we set different levels of zoom in each of the two cameras. We use the overload of Matrix.CreateScale() that takes a Vector3 to create a scaling matrix. However we could use the overload that just takes a float and pass the zoom value as a parameter with the same result. Unsurprisingly applying the scale, scales .

Finally we want to center the tank in the middle of each viewport and that’s why you apply the last line (line 17 on the sample above).

And we are done tho I’m sure there are plenty of ways to improve the code, but hopefully it will help as a simple example.

If you want to have a better look at the code, a working sample is available here. If you have any comments, improvements, questions, as always you are very welcome.

**UPDATE: **I followed up with a post about Spring Camera here.

Windows Phone 7 - Game Development Experience

Tue, 06 Dec 2011 13:27:59 +0000

I got a Windows Phone 7 to play with for a while and these are some notes about the experiment. I just did a tick-tac-toe based on this blog post changed a few things tho (like the use of extension method for checking for wining and replaced by bit shifting :D ), but I wanted to have some code to fall back to just in case.

NOTE: I have an android phone, and had an iPhone for a while in the past, so my expectations about this phone are probably based on them.

As soon as I connected the phone to my computer it prompted me to install the Zune software, after installation you get this:

restarting my machine? we are not in 1999, this shouldn’t be a requirement.

Also when I was trying to install some game, the phone displayed a message about the fact that some installations require re starting the phone. Very strange

Rather randomly on an LG –E90099 I get the error that the phone is pin locked (it isn’t :( ).

If while trying to debug to your phone you get an error, “The application could not be lauched for debugging. Verify that the application is installed on target device” that, for me , meant that the phone was locked (ie dark screen) Make sure you can see the menu and try again

After these initial errors, I pretty much moved pretty quickly.

I am quite surprised by this, but at least for game development (with xna) this little trial has been incredibly painless.

Regarding the phone OS, there are some aspects that I really dislike:

A lot of screen is wasted, for example if i search online for something, I can only see about 2 to 3 results.
The facebook integration (I dont want facebook). Probably it can be turned off?
Figuring out how to un-link the hotmail account to the phone is quite tricky (it might be just me)
Having to restart your phone after installing an app is just not acceptable.

Things I liked about the phone

Dealing with text in general is superior at least to the android experience. ie writting texts and email was a good experience
Generally fast and non cluttered

In general my perception of the phone has improved after trying it . And I have to add I’m pretty impressed by the Zune software, it looks good, it worked flawlessly. Comparing to iTunes and Samsung Kies it’s way ahead.

I like XNA, and the fact that it was so transparent to deploy a game to the phone was really nice.

Programming Science

Tue, 22 Nov 2011 09:40:04 +0000

So a few Scientists and a few developers met last Wednesday. It was hard to know where we were going to end and thanks so much to everyone that participated. The following is a summary of the tips we (scientist + developers) thought was a good idea

Tips for scientists writing code (1st Round):

Talk to other scientists that work on similar projects and share a list of your most used functions (I cant remember the name of the person suggestion
Every now and then meet up with other scientist writing similar code to you to talk specifically about the code you write, after all if you know the tools you are working with better, you are bound to be more productive
Use source control. There are pretty good open source alternatives and many places that offer free storage. Some source control options: Git, Mercurial, subversion. Some places to host your code: github, bitbucket, google code, codeplex
Use variable names that indicate what you are talking about.
- Some bad examples: your_cat_name, sss, ttt, etc. Some good examples: portionOfSphere, portion_of_sphere.
In the case of IDL, avoid for loops and try to use functions
Try to get used to reading others people code so that you realise where you can improve, or point out things that can be done i na more effective way

Help a scientist day

The above is all well and good, however. We were also thinking about collaboration. So Philippe came up with a great idea: Help a scientist day.

A scientist submits (somewhere to be discussed) a problem she or he thinks it could be solved with some help of more developers
people can ask questions about the idea (either technical details or just to check that its a problem similar to theirs)
People can vote on ideas (no need to sign up )
The ideas with most votes (that are doable) will be the ones that will be implemented by developer during “Help a Scientist Day”

So, we need to organize this day, please comment on G+ so we can get this going

Cheers

Starting out with XNA? some handy links

Mon, 07 Nov 2011 21:19:03 +0000

XNA is the SDK from Microsoft for game development.

XNA getting started tutorial. Well organized, paced series of XNA tutorials by a guy that teaches this. If you know nothing this is pretty good.
Xna workshop. Some posts and links to learn XNA Is kinda handy to see other people’s questions
Riemers XNA Tutorials. I think this is a link you want to keep, every time I search for something XNA related I get a post from this guy
2D Camera with parallax scrolling. Does what it said on the tin, very comprehensive article that also links to other interesting articles.
Mono game. The good news is that there is a port :D … “MonoGame is an open source implementation of the XNA APIs that allows developers to build 2D games that run on Android, iPhone, iPad, Mac, Linux and Windows using the same code base, or reusing existing XNA code that runs on Xbox 360 or Windows Phone 7”

I ve been reading Learning XNA 4.0 its pretty good so far, well written and easy to follow tho with enough detail.

If you know of other good details, please comment :D

Code Retreat Dublin - 17th September

Sun, 25 Sep 2011 12:06:09 +0000

What an awesome experience to organize and participate in this event.

It was a long day but I think people enjoyed it, learned a lot and got to try a few new things.

At 9, Jose explained how a Code Retreat works and Kevin(below) explained Conway’s Game of Life, the problem to solve during the day.

Sessions

A code retreat has many sessions of 45 minutes each. Below is how most of the sessions looked

Session 1

At 9.10 am we started our first session.

Constraint: To code Conway’s Game of life in pairs.

At the beginning of the session all the pairs were talking to each other, but after 5 min or so we saw a change towards writing code.

Retrospective:

A few solutions to the problem emerged.
A healthy discussion about the problem constraints.

Pair count by language:

Python: 3
Ruby: 4
C#: 2
Php: 1
Javascript: 1

Session 2

Constraint: To discuss the solution for 10 min, and to test drive or unit test the solution.

Retrospective:

A pair came up with a solution that used 2 lists. More people using javascript, as it’s a language that most can understand. Jasmine (BDD for Javascript) was a handy tool since you can run it in the browser.

Pair count by language:

Python: 3
Ruby: 2
C#: 2
Php: 0
Javascript: 3
Java: 1

Session 3

Constraint: Avoid the use of primitives.

Retrospective:

In this session we got more feedback:

As a result of the restriction we got self documenting tests
Not enough time
Arriving at a better design
One of the pairs spent most of the time just analyzing
Some questions about testing in general. What do you do when tests are just too big? The general answer was around the lines of break it down into smaller tests and skip or remove from code and add to To do list. Another question was about mocking

Pair count by language:

Python: 2
Ruby: 1
C#: 1
Php: 1
Javascript: 3
Java: 3

— Lunch Break. Retrospective: Yay! —

Session 4

Constraint: TDD as if you mean it tho since not everyone was comfortable with testing, it was optional.

Retrospective: Four pairs tried TDD as if you mean it, however the concept wasn’t very clear. (this was probably my fault, as I explained it badly, sorry)

Pair count by language:

Python: 1
Ruby: 2
C#: 2
Php: 0
Javascript: 3
Java: 1

Session 5

Constraint: No conditionals

Retrospective:

The general feedback was that the pairs felt that they were arriving at more elegant solutions with more classes, which resulted in more readable tests.

Pair count by language:

Python: 2
Ruby: 1
C#: 2
Php: 0
Javascript: 2
Java: 2

Session 6

This was the last session after a long day. The feedback on the ground was that people felt a bit frustrated that they didn’t have enough time to finish the problem; so session 6 was: Finish the problem.

There was no retrospective as people started to leave. However it felt like people left happy. Splitters!!

NOTE: There is another Code Retreat in Dublin this coming 3rd of December as part of Global Day of Code Retreat check CodingDay.org for more details

TDD tools for net developers

Sat, 09 Jul 2011 11:49:46 +0000

In the last few years the tooling available to .net developers for unit testing in general has matured, these are some of the tools that I either used or heard of :

Continuous Integration:

Team City: I use it and really like it, simple to set up and use, if you want to try it they have a free professional edition .
Cruise Control.net: Open source, used it but didn’t find it too friendly, I’m aware a lot of people use it
Hudson. Originally a Java only project but there are some success stories on the .net fence, has some features unavailable in the other two mentioned above.
there must be something else. ?

BDD Frameworks

StoryQ: This is what I use. Like it because you write C# code with some constraints and it generates reports on the behaviour. Samples: code report
Cukes/Cucumber: I remember the first time I saw cucumber in action I was really impressed, however it’s hard to get buy in for a tool that requires another language installed, probably fine for some projects, it depends a lot on the project, the company and the culture.
SpecFlow: you write features in Gherkin(the cucumber spec language) that are then compiled into c# code. Nice reports, but I find the generated code hard to read… ie a bit too verbose (example feature example generated code) however I wouldnt discard it totally.
NSpec: You write c# code (very lambda-y) and it generates reports.. like it even less for reasons similar to the above, have a look at it yourself here
Fit/fitnesse: I haven’t tried it, it supposed to be very good, I ll leave that one to you (would love some feedback on this if anyone reading did try it)

Unit Testing Frameworks.

xUnit: a nice, compact unit test framework, I like it because it has less noise, no setup method (ie it uses the ctor for
nUnit: The most popular one.
mbUnit: good support for RowTests.
_
msTests: the option by Microsoft. I tried this framework when it came out, so perhaps not valid anymore. My experience with it was that the same set of test ran 20% slower. Also it had poor support for theory tests. Maybe this all changed. I will guess that anyone using this framework does it because they can’t use anything else

Builds

Psake: powershel based DSL for building
Rake: Ruby based Dsl for builds, nice to use ruby, but sometimes needing the ruby dependency is a deal breaker
Nant: not something I would choose, but hey if you like xml this is the way to go (if you like Xml you might want to talk to your doctor too ;) )
MSBuild: I find it non intuitive, I thought I was being unfair so I asked in twitter what ppl thought of it. One supporter and 4 not really happy with it (see below)
Final Builder : a commercial option, and not a bad one to be honest. Very easy to use (drag drop style) tho not as flexible as we needed.

Code Coverage

NCover: does the job but I think the generated graph could be better. Running the tool was cumbersome too as far as I remember
dotCover : really nice and integrated with resharper, it a bit rough around the edges with lambdas and other minor things, but a tool I use day to day

Feedback and anything that wasn’t mentioned yet , please feel free to comment

Cheers

DDD Scotland. Review and Slides

Wed, 11 May 2011 10:25:04 +0000

During the past weekend I was at DDD Scotland, it was great to meet all the people there.

I apologize for the amount of lolcalts that I added to my presentation (available below) and any feedback, etc more than welcome.

[slideshare id=7891964&doc=cqrsesandfriends-110509044316-phpapp01]

In many ways it was good to get the presentation out of the way early because it meant I could focus on being out there listening to other folks smarter than me talk and meet some people.

After my talk I was at Gary Short’s presentation on hoe to measure performance, interesting and really well delivered. Some interesting questions too.

Then I was at Seb Rose talk on TDD and unit testing. It was interesting to see that you can test drive a C++ app. His advice was sound. He talked about the importance of setting a structure before starting to test. He talked about the importance of deployment. And how it was important that the tests were also clean and well designed. Link to his slides

After that there was lunch, unfortunately (or not) I couldnt catch any of the grok talks as I was talking to people, one of the ideas we had was to open source a project (not mine :S) that would make using selenium+qunit on CI easier… will see how that goes.

After that I joined a talk by Toby Henderson, The dark parts of Mono. I reallly enoyed this talk. Info about small standalone tools or libraries that you can use, with examples. Such as IKVM, Cecil, SIMD, Compiler and Gendarme.

Finally, I joined the “Ask the Speakers” panel, very relaxed and quite fun. We talked about the news (Mono and its future, other stuff I cant remember - please comment), innovation and community. There is a post of note that goes into some of the stuff we talked about .

All in all a great event, thanks to everyone for making it possible.

DDDScotland next weekend 7th Of May

Sun, 01 May 2011 16:26:50 +0000

DDD Scotland is happening next weekend, I’m really looking forward to it. I’m also very happy my talk got selected, thanks everyone that voted for it. The agenda is very interesting here are my picks:

Starting at 9:30AM and If you are not interested in CQRS/ES, there is two talks that sound interesting: Streams of Streams – Your Rx Prescription, by Ray Booysen and Chris Canal ‘s Monodroid Introduction, I could really use seeing a talk on this as I’ve been playing around with it lately. Conferences are really those times when you wish time could effectively go backwards, damn causality… (look here if you want vaguely related lolz)

Later on Decision time again, there are two talks that I would be interested to see: Asymptotics and Algorithms - What You’ve Forgotten Since University by Gary Short. I’m not going to lie, I had to look up what Asymptotics meant . The talk is about calculating the efficiency of an algorithm, something we tend to leave to the framework these days.. but we probably should know about. The other talk I’m interested in is Barry Carr’s Caliburn Micro talk, it seems like that framework has packed some very interesting ideas, I only heard some of them after listening to that Herding Code podcast with Rob Eisenberg.

The talk about scalable web with Asp.Net sounds interesting too .

At 12:00 there is a talk that I need to go see, that’s Seb Rose’s talk on unit testing, reasons being: first, because its about unit testing, but the Skeleton reference I like too, the fact that he contributed some of the 97 things every programmer should know(or architect, cant remember which one) . Another talk that interests me but I wont get to is BDD with F# By Phillip Trelford

After lunch there are three really interesting sessions that I’d like to see:

Seb Lambla’s “Building composite applications with Open frameworks” from a very quick glance at the video available in Channel 9, it looks like a talk about using OpenWrap, and how to integrate it to your workflow, and that’s something worth watching.
“SpecFlow – functional testing made easy” by Paul Stack, would like to see how it compares to StoryQ…
“The dark parts of Mono” by Toby Henderson, interesting cause I ve been meaning to see this for a while.
If I was into Silverlight at all, the talk to not miss would be Daniel May talk on Silverlight Unit Testing “Real World SLUT (Silverlight Unit Testing)”

The last sessions of the day are also pretty interesting, I think the one I ll end up in would be: “How to build a framework, and why you almost never should.” by Richard Dalton , a last minute change could see me going to : “Rewriting software is the single worst mistake you can make – apparently.” tho what puts me off this is a probably wrong, and its the fact that is a story of migrating to VB.Net, a language that I honestly can’t understand why still exists or why does Microsoft funds, but leaving that aside sounds like a story worth listening to.

See you there

Clarifying CQRS[Udi Dahan] Spanish Translation

Thu, 14 Apr 2011 18:10:58 +0000

Hi :

Recently a group of us (tho mostly Pablo Nuñez ) translated the article from Udi Dahan Clarifying CQRS. Here is the link to it, if you feel that it can be improved please just leave a comment here and I can add you to the document with edit rights. Some terms where hard to translate.

Thanks to Pablo, Carlos Peix , Jorge Gamba and everyone that retweeted and helped.

Hola:

Me pareció que el articulo de Udi Dahan, Clarifying CQRS, podría ser muy útil para la comunidad de desarrolladores hispano hablantes.

Así que algunos de nosotros decidimos traducirlo, aquí esta el link , la mayoríadel credito debe ir a Pablo Nuñez . Pero también gracias a las demás personas que ayudaron: Carlos Peix , Jorge Gamba , etc (la verdad no me acuerdo quien mas perdón:) )

Si tienes algún comentario o corrección simplemente deja un mensaje aquí y te puedo agregar al documento con derecho de escritura.

Gracias

Learning CQRS. Why not using a framework is a good idea

Tue, 12 Apr 2011 11:55:32 +0000

I ve been talking to some people over the past few months about CQRS, particularly CQRS/ES and at some point of the conversation I get the **framework **question.

I think the implementation of the patterns CQRS and ES is not trivial (it’s also not necessary to do both , but lets keep going) however, the escence of the advantages you get out of both comes from implementing the rules of the domain, in the domain. By making the state transitions explicit.

The number one reason why you should learn about CQRS without a framework is because, it could cloud your understanding of the domain with artificial constraints. Another important reason is that when you learn by doing, you understand the workings and shortcomings of a particular methodology.

That is not to say that frameworks are bad and you should never use them, but make sure that when you make a decision like that, it is a conscious one.

I remember one day when I was at a talk by Gregg Young, and he said: How many of you use (ms)SQL? How many of you made that conscious choice? (ie to use an relational database for storage) . I realised then that, I didn’t make that choice or considered an option in certain cases, but what scared me the most is that I was making a bunch of assumptions as soon as anyone said “system” , it made me realise that most of those assumptions could blind me into not really considering all the options.

Why Setters and Getters are considered a code smell in your Aggregate Roots

Sun, 23 Jan 2011 19:38:11 +0000

Say we are not concerned with the query side of things (because we have an autonomous query service that need not know about your aggregate roots). With that in mind, in which cases do we need to know about the aggregate root private data?

I can think of one case - when checking for duplication. Then we would have to

* Be happy with eventual consistency (ie some check before actually trying to save) or 
 
* rely on the persistence layer for uniqueness and on failure, get a meaningful error. 

In any other situation, we are likely to be doing something that is meaningful to your domain. For example, lets pretend a product stock amount had to change, the code would look like this

[sourcecode language="csharp" padlinenumbers="true"]
Product product = _repository.Get(id);
product.Stock = 2;
_repository.Save(product);

class Product
{
     public int Stock {get; set;}
}
[/sourcecode]

That code would have probably lived in a service, or even worse, in a controller What are the problems with this?

Lack of intent. When you look at the code for Product, you’ ll see a Stock (or quantity) property, and in this case its a pretty simple field. However you have no idea from looking at the code, how this property is used.
Possible implicit behaviour. There is always a chance that the setter contains some logic .
Context, perhaps adding Stock has certain rules, maybe when >100 are received then someone has to be notified, or they need to be moved to another warehouse.

Instead, you can write an AddStock method, which in reality would do something a bit more explicit ( I’m sure you could call it StockDelivered or similar, but I guess it depends on your domain …)

[sourcecode language="csharp" autolinks="false"]
Product product = _repository.Get(id);
product.AddStock(45);
_repository.Save(product);


// and in the product AR
class Product
{
       public void AddStock(int receivedStock)
		{
			Contract.Requires<ArgumentException>(receivedStock>= 0);
		   	_stock += receivedStock;
		}
}
[/sourcecode]

This is a more explicit design. However, the question of testability comes to mind, and the way you write your tests depends on the flavour of DDD you are using. If you are using DDD with CQRS/ES, then you would be publishing an event with the changes. If you are not, then you could rely on checking the product stock before and after the operation, through a query service.

Related Articles

The Flawed theory behind unit testing (Feathers)

Doing it wrong: getters and setters

CQRS/ES Presentation in Belfast yesterday

Fri, 21 Jan 2011 15:31:24 +0000

I was in Belfast yesterday were I was presenting what I called “CQRS/ES and friends” in NIMTUG . I had a great time thanks to all who came and thanks to the organizers.

I would normally post here my presentation, but not sure its of any value, as it doesnt have much info, I use it for helping me remember what to say, if anyone want it, i can definetly post it, just add a comment here.

The code I was showing is a fork of Super Simple CQRS code example by Gregg Young

I have a link (bit.ly bundle) with a bunch of links about CQRS and ES, including a few other sample code bases http://bit.ly/9LC877

If you have any questions, or feedback good or bad (something missing?) please let me know by posting a comment here (if you don’t want me to publish it just say so )

Thanks for coming :)

What is CQRS and other related terms - Modelling and testing - Part 3

Mon, 03 Jan 2011 13:20:19 +0000

This post belongs to a series of posts on CQRS/ES

Part 1 – introductory terms and overview

Part 2 – Event sourcing and information about commands

So, we are moving on.

I thought I’d put these two topics close, it seems to me that they are related, I ve been using BDD to test this

After all, what I’m testing is much more than a unit, and I’m interested in the whole loop. What I find interesting here is that since we are talking about actions when we talk about commands and we are also talking about past events, the Given, When, **Then **become very rather obvious.

So, you can say something like:

Given a NewCustomerCommand with "Name"
 and a NewCustomerCommandHandler
When I Execute the Command
Then a CustomerCreatedEvent is published
 and Customer with "Name" exists

and, if you, like me, are using StoryQ, this story can look like

                .WithScenario("Create new customer")
                    .Given(ANewCustomerCommandWith_, "Name")
                        .And(ANewCustomerCommandHandler)
                    .When(IExecuteTheCommand)
                    .Then(ACustomerCreatedEventIsPublished)
                        .And(CustomerWithName_Exists, "Name")

With this in mind, its not hard to imagine the code to make this happen, and because of that, the focus remains on the modelling, when I see this code, I can’t help but think, Do I really need to create a new customer to be able to process orders? Is the name all that relevant?, maybe the email is more representative… all of these are domain questions, this is exactly the kind of questions that should arise, this focus is on the domain is one of the most interesting advantages of CQRS. And we need to change our code. Your testing points are at the command level, at the query level and/or at the event level.

An interesting advantage of testing in a BDD style is that you have very concise, runnable documentation, and can kick the conversation off, with your domain expert. Here you could say, wait a minute, my domain expert doesn’t know about commands, or queries. Well then perhaps you need to move the layer of testing up a bit higher to the UI. Testing points go a layer above, another option is test at both levels.

Summary

Behaviour Driven tests help you model the domain
Your testing points are your commands, command Handler, query services and events. No need to mess around with aggregate roots directly, and hence why no need for getters on the aggregate roots
Your tests are executable documentation

UPDATE: Next up Validation

What is CQRS and other related terms - Part 2

Tue, 30 Nov 2010 19:00:47 +0000

CQRS with Event Sourcing

[caption id=”” align=”alignleft” width=”269” caption=”Photo By edinburghcityofprint(flickr)”][/caption]

Looking at CQRS and Event Sourcing as Architectural patterns, when we use them together the impact of that is widespread. For a start, your aggregates should only be exposing behaviour, and that behaviour is related to the commands that use that aggregate root, actually, the entry point to doing anything in the domain is through a command. (this have implications on how we test, but we’ll talk about that later on).

The aggregate root should now expose only behaviour, encapsulating all state, setters are seeing as a code smell. This change is not a direct consequence of CQRS, however, it was very hard to achieve this without it if doing DDD.

One of the questions I got during the talk was about how to replay perhaps millions of events, without a huge delay, and the answer to that is Snapshots, basically you preserve the current state of the aggregate root, serialized . There are a few ways to do snapshots, but the principle is that you get your snapshot, which will be up to a particular version, and then replay any events from that version on ( if there are any).

At the system level, it is important to note that, we now have an explicit state transition, what I’m trying to say is that when your customer (ie the person that comes up with the requirements for the system) sais something like, when a customer is created, then that can be mapped directly to CustomerCreatedEvent ie, there is a close relationship between what happens and what caused the state transition and that can be relevant to the business. This, I think, is the biggest advantage of using CQRS

Since the read storage and the Write storage are logically separated and they can be physically separated too, that means, that they can have different scaling policies.

Another interesting benefit of using event sourcing is that you have an integration point available, without any extra cost. The integration point could serve a Reporting tool, or an external service, or maybe you just want to push some sort of notifications, these are all easily doable, you have a bus publishing messages…

Actually, the way we are using event sourcing in the above stated scenario implies an eventually consistent model. If interested in this topic, have a look at this blog for the cost of eventual consistency. We ll go through some code and then come back to this topic.

I don’t think I mentioned this yet, but, there is one really awesome thing about this whole thing, and that is that we are framework free, there are a few principles and ideas to learn, but once you got them, there is not really much that you need a framework for, maybe if you want you can have an out of the box event store, they are simple in principle but a bit harder to code that it appears first. There are some frameworks to do CQRS with ES however, the code you need to have a system like this running is not so complex, and understanding how it works is crucial.

The trail of the Command

Lets forget about the UI for a second and think of a system from the point of: I have a command, and I need to execute it.

Every time you send a command, the system handles the command, more than likely, an aggregate root will be involved and an operation on it will occur, this will result in one or many events being published; once the event(s ) have been published, the subscribers will get this message. One of the subscribers is the Event store, that will append this new event. There are variations of this description but this will do for now. Lets say the

public void Handle(CustomerMovedCommand command)
        {
				var customer = _repository.Get&lt;Customer&gt;(command.CustomerId);
				customer.Moved(command.AddressLine1, command.AddressLine2, command.Postcode );
				_repository.Save(customer);
        }

the aggregate root (Customer) code for that method could look something like this

public void Moved(string line1, string line2, string postcode)
{
    ApplyEvent(new CustomerMovedEvent()
                        {
                            AddressLine1 = line1,
                            AddressLine2 = line2,
                            PostCode = postcode
                        });
}

In there we can see that we are applying the event, once we apply the event, we will not only set up the internal properties of the aggregate root(that we need for write operations), also through the repository or other commit like mechanism(we’ll look at this in a sec), we will publish this message, making the event store aware of this new event and making the query side aware of this event too, the query side is then responsible of de-normalizing the data to a suitable shape.

An important thing to note is that the event is declared as something that happened, it is in the past, for example: CustomerMovedEvent, that means that as far as our system is concerned, the customer has moved.

Next part will include Modelling and testing

I bundled a few interesting links in this bit.ly bundle** http://bit.ly/9LC877 **

What is Command Query Responsibility Segregation (CQRS ) and other related terms - part 1

Wed, 17 Nov 2010 22:19:37 +0000

I’m preparing for a talk on CQRS and I though I’d support it with a series of posts on the subject. I’d love to get some feedback on this and all the following blog posts. (where I ll be possibly correcting stuff i say here, I can’t promise)

So, I decided to start at the beginning: definitions. When I started to learn about CQRS I just looked at a good few videos, read a bunch of blog posts and then dived into every code example I could find, and then I’m working on a system that uses these principles. However, I wanted to roll back and see if I can somewhat formalise what I’ve learned so far. Starting with definitions

What is CQRS?

Based on this blog post and others , the consensus is something like: CQRS is a pattern that describes the separation of command messages , they change state, from query messages that read state.

Please note this is a pattern (i.e. not an architecture) . if you look around online you ll find that some people seem to see CQRS as a software architecture, it makes sense that this is confusing, I wonder if the “term” evolved so much that it lost its meaning, what most people refer to as CQRS is actually a combination of a good bunch of patterns that work well together.

CQRS is normally used with other patterns such as event sourcing, messaging patterns, task based uis, etc. I’d like to make an emphasis on the guideline bit, for me this is a powerful word, it tells me, something like, paint it some shade of yellow, but I have the choice to use the yellow that makes the room the way I need it to be.

Before I started looking at CQRS I was unclear about the relationship between an Aggregate root and the services that serviced it or worked on it. Once I started looking at samples of applications based on CQRS with ES, which was about the time we finished reading the DDD Blue DDD Bible, then it all became clear. I think the main thing was that the boundaries of the aggregates and the boundaries of each domain were more tangible and made more sense.

Also if using CQRS, you ll find that your aggregate roots change shape, i.e. there are no public properties, at the very least you ll have no public setters, and all the methods in the aggregate sound more like actions, if you have methods such as AsDto(), that definitely means you are doing something wrong. Also you are loosing all properties that you needed for the read side of things, for example if you had an Order aggregate root, do you really need that OrderItems collection? you have access to that collection through the OrderQueryService.

The term CQRS, evolved from CQS(Command Query Separation) there is a CQS definition from Meyer, that is very similar but it’s separating methods that change state, since the emphasis is on messages for CQRS, this was an important distinction.[ref]

To prepare for the talk I’m also preparing an example (more later), the interesting thing is that, I find that using CQRS and Event Sourcing, I find myself asking questions about the system and the domain, and that is great, because it makes you focus on what the system should do, not the how.

That brings me to another important definition.

What is Event Sourcing?

Event sourcing means that you capture changes to an application state as a sequence of events (definition by Fowler) . Imagine most systems your worked with up to now, If you had a customer, and they moved, you would probably go to the user interface (web or whatever), go to some sort of customer edit screen, change the details, and thats it, most likely this would trigger an update operation in a normalized database, and unless there was a specific requirement, you’ve not only lost the previous value of the address, also, you dont know if the customer actually moved or if the address was incorrect, so you are loosing history and intent, two very valuable assets.

An important detail about this way of storing data is that its an **append only model **, because you are only adding, the write operation its simpler, this means it takes less time. Another consequence of an append only model is that to change something, we would apply compensating actions. Interestingly, once the events are stored they are immutable.

If this is such a great way to store data then how come we are not using it everywhere? you might ask. Well there is the problem of having to replay all events to build an aggregate root each time you need to work on it, and hey, what if it’s a very busy one, and there are millions of events to replay. For that, we would use snapshots, i.e. every so often we would record the current state of the aggregate root as is and then when we need to get the aggregate root, we would have to find the latest snapshot, and then replay any outstanding events to get to up to date. The real culprit is the fact that selecting the top 3 orders where the customer name is Bob, is kind of hard. However, since we are using Event sourcing on the write side and we might just get away with it .

Event Sourcing is a big theme, the Event store is one of the most complex parts of using CQRS/ES. There are a few open source implementations out there. Olivers comes to mind

References and Sources

CQRS and Event Sourcing – Gregg Young

Clarified CQRS – Udi Dahan

Domain Driven Design Website

Command Query Separation – Gregg Young

StoryQ Review

Fri, 12 Nov 2010 15:02:09 +0000

We are evaluating BDD frameworks at the moment and I’m going through StoryQ.

Note:

Internal DSL for BDD, for me this means I can discover a lot by just following the API (ie its got a nice fluent API)
The Code for adding a story is very simple (example below)
Readable and nicely formatted report output
Supports Nunit, xUnit and MSTests
if using xUNit there is no support for incomplete tests ( ie if you are using CI it will break the build) UPDATE: there is a way since xUnit 1.7
Also you need to override the settings with your own exception builder.
I had one of those Doh! moments because I setup the story and the scenario with the Given().When().Then() and then I called the Execute method, that was not going to work… :(
Can report in various format, the report shows up on resharper or in an more html way.
There is a wpf app that converts gherkin and it generates the StoryQ test.( couldn’t try because the app failed, I think it s because of a dodgy build I have but will find out and report later)
Seems to support well the idea of many scenarios per story within the same file, which is cool.
Good to keep in mind not to use underscores in method names Link

So far so good, if there is anything else noteworthy I ll update.

7L7W - Scala Day 1

Sun, 31 Oct 2010 15:49:58 +0000

In the Book Club, we are reading 7 Languages in 7 Weeks (for more info on the book club go to Dublin Alt.Net mailing list) so far a really awesome book, Its helping me have a quick view of not only different languages, but also different programing paradigms. Which is really refreshing, but hard. The thing that I like the most about the book so far , is that you do much more than a hello world, but of course, you can learn in depth, however, the author makes a really good job of explaining what’s at the core of each language, sometimes, just trying to really grasp that is a tiny bit hard , when it’s a paradigm you are unfamiliar with it, but the effort is well worth it.

Anyway, since I haven’t been able to the last two meet ups, I thought I’d do a second read of the Scala chapter and put together some notes. Please note I’m writing the notes as I read.

Scala is a hybrid language (a mix of OO and functional)
Hints that its a different kind of language
Runs on the JVM, though given the state of Java, not sure that is any kind of insurance. Scala can use Java libraries natively, just like Iron* languages , can use .net libraries directly
Statically typed
type inference (like c#? –> review)
functional concepts, like c#? it would be awesome if it added some native support for immutable types
Support immutable types, but its got some modifier ( need to check this out more in depth)
actors

Scala is a general purpose language, interesting that it seems to fit well many scenarios because of this OO, Functional mix Type inference seems to be not so strong Principles of functional programming that apply to Scala:

programs are made of functions
functions return a value
given the same input, a function will return the same output
side effect free

val is immutable var not …. Likes

There is a full page on the book dedicated to somewhat clarifying strong vs weak and static vs dynamic languages. I mostly agree with his points there.

My first impression when seeing the language was that it reminded me more to python than to java, maybe it was def .

Visibility of methods, functions. Public is default
Support for tuples and ranges . In purely functional languages, tuples are used as objects. You can do multi value assignment with tuples
Constructors. I like Scala’s syntax and default
Object instances are interesting, at first I was thinking they were like static classes in C#, but apparently not quite. As far as I understand, an object declaration in Scala is basically a singleton instance of a class definition. However, in C# a static class is a class that can be accessed and used, without creating an instance. That makes me think that there is a cost associated with the instantiation, but I cant see any other difference. (comments on this would be appreciated)
traits. Like an interface and an implementation all in one, generally focusing on a single concern, well that’s what the book say, however I can’t see here how you do to declare a trait separetly

As Part of the exercise of Day 1 you need to find a comparison between Java and Scala(I found this), one of the interesting things I learned while checking that out is that XML is supported natively, I also liked the point on moving to a more functional style of programming slowly, but with a nicer syntax.

Open Source and you - Resources

Sat, 16 Oct 2010 11:52:48 +0000

I was invited to give a talk on Open Source in DIT to a group of students. Link to slides http://www.slideshare.net/roundcrisis/open-source-and-you-5456161.

However here some interesting links:

35 years of Open Source http://vospe.com/2010/09/22/a-brief-history-35-years-of-open-source-software-a/
The Open Source Initiative http://www.opensource.org/
List of Open Source Licenses http://www.opensource.org/licenses/category and more here http://en.wikipedia.org/wiki/Comparison_of_free_software_licenses
Reddit’s Open Source http://www.reddit.com/r/opensource/

Manos de Mono - Quick overview

Wed, 13 Oct 2010 20:00:45 +0000

I heard about this new web framework the other day, the code its available on github/jacksonh/manos the main interesting thing I heard about it were:

runs on Mono
Has its own server
Has no dependecies on Asp.net
the main goal of mono is to simplify web application development
routing appears to be simpler ( to use and test)
command line for managing your apps (deployment included)

At this point, I wanted to see some code, I went to the example on github and I was pleasantly surprised

[sourcecode language=”csharp” padlinenumbers=”true” collapse=”false”] // // A mango application is made of MangoModules and MangoApps // There really isn’t any difference between a Module and an App // except that the server will load the MangoApp first. A mango // application can only have one MangoApp, but as many MangoModules // as you want. // public class MangoProject : MangoApp {

	public MangoProject ()
	{
		//
		// Routing can be done by using the Get/Head/Post/Put/Delete/Trace
		// methods. They take a regular expression and either a method
		// or another module to hand off processing to.
		//
		// The regular expressions come after the method/module, because
		// Mango uses params to allow you to easily register multiple
		// regexs to the same handler
		//
		Get (Home, "Home");

		//
		// The Route method will hand off all HTTP methods to the supplied
		// method or module
		//
		Route (new DocsModule (), "Docs/");
	}

	//
	// Handlers can be registered with attributes too
	//

	[Get ("About")]
	public static void About (MangoContext ctx)
	{
		//
		// Templates use property lookup, so you can pass in
		// a strongly typed object, or you can use an anonymous
		// type.
		//
		RenderTemplate (ctx, "about.html", new {
			Title = "About",
			Message = "Hey, I am the about page.",
		});
	}

	public static void Home (MangoContext ctx)
	{
		RenderTemplate (ctx, "home.html", new {
			Title = "Home",
			Message = "Welcome to the Mango-Project."
		});
	}
} [/sourcecode]

Like the module and App ideas
like the simplicity of the code above
seems to work at a slightly lower level of abstraction than MVC but I can live with that
Interesting that it uses it’s own template engine, the syntax is nice, but I wonder why not spark, razor, nhaml, nvelocity. After all, It would be cool to use what I know already. Will have to find out.

Will have to do some more research on it

Projects Organization - How to organize assemblies in your local machine to avoid nightmares

Wed, 22 Sep 2010 19:11:20 +0000

This is just how I organize folders and projects on my machine, there are endless possibilities , but I saw someone searching for it online and it did took me a long while before I settled on this, so I thought I would blog about it.

This can be a good or bad way of organizing, I think it depends on the kind and number of projects you are working on

Imagine you have a folder that contains the following folders

code (Real code, shipable, or company proof of concepts with its own repo)
**spike **(test to see if something works, Proof of concepts very basic)
third-party (OSS libraries and frameworks, etc)

Inside my code folder, each solution has it’s own Lib or Libs or Libraries folder (eg One Lib folder per solution ). The story is very different in spike **since I put projects there for stuff I never ever want to ship then I have a shared **Lib or Libs or Libraries folder where I put everything I ever needed. In third party I leave as I got from source control .

Inside the Libraries folder I mostly try to keep a folder per project and inside a folder per version, something similar to this

if in doubt copy the assembly, disk space is cheap.

Reflection - Create an instance of a class through a protected method

Thu, 16 Sep 2010 20:01:04 +0000

I had a bit of trouble getting to this, so for self reference more than anything, I thought I d post about it.

Given the following class

    	
        public class MyClass	
       {		
               private string _name;
    
               public string Name { get { return this._name;}}
    
               protected MyClass(string name)
              {
                   _name = name;		
              }
      }

I thought that the following would be the way to create an instance of it:

    Activator.CreateInstance(typeof(MyClass), BindingFlags.NonPublic, null, new object[] { "MyName" }, CultureInfo.CurrentCulture);

However it throws a MissingMethodException: Constructor on type 'ReflectionCreateInstance.MyClass' not found. However if we add the Binding Flag for instance then it works.

    	
    [Fact]
    public void When_creating_with_activator_Must_use_apropriate_binding_flags()
    {
    	string myname = "MyName";
    
    	var myClass = (MyClass)Activator.CreateInstance(
    					typeof(MyClass), 
    					BindingFlags.Instance| BindingFlags.NonPublic, 
    					null, 
    					new object[] { myname }, 
    					CultureInfo.CurrentCulture);
    
    	Assert.Equal(myname, myClass.Name);
    }

If you try this with <b>type.GetConstructor</b> or <b>type.GetConstructors </b>the result is the same. 

Checking the <a href="http://msdn.microsoft.com/en-us/library/system.reflection.bindingflags.aspx" target="_blank">documentation for BindingFlag</a>.Instance I find </span>

<a href="http://roundcrisis.files.wordpress.com/2010/09/capture.png"><img src="http://roundcrisis.files.wordpress.com/2010/09/capture_thumb.png" style="display:inline;border-width:0;" title="Capture" height="370" width="674" alt="Capture" border="0"></img></a>

So it was a case of RTFM I guess :D

Irish Open Spaces Coding Day III Retrospective

Sun, 12 Sep 2010 15:40:31 +0000

Yesterday we had the 3rd IOSCD. It was great fun, the code is all available here.

The sessions

and

It was great to have some hardware to play with, people really seem to get a good kick out of that, there was a Netduino and two Lego NXT.

I’m hoping that other people will tell us about their experience yesterday (hint hint ;) ).

Some of the sessions included: Ruby on rails app for the book club assistance (called and_on_that_basis , no idea why), netdruino hacking with some sort of Rx , and then using Rx over the wire, finally i was working on something called Code Shapes.

Just starting a tool(?) that will analyse each class and draw a diagram:

Hollow Ellipse - public method
Shaded Ellipse - protected, private, or package private method
Rectangle - field
Line - a use-dependency from a method to a method or a field.

as per Michael Feather post on this.

2010 Events Coming Up

Mon, 23 Aug 2010 21:49:09 +0000

There is a bunch of things happening in Dublin in the next few months, I figured it would be handy to push a post on it.

30th of august - Windows Phone 7 . A joint event between MTUG and Dublin Alt.Net - Registration and Details

9th of September - Promiscuous Developer Meetup (location not confirmed) developers of different languages meetup and try to find the answer to life, the universe and everything, maybe it wont be 42 :) sounds kinda interesting. More info here.

11th of September - Open Spaces Coding Day III - A full day of coding on whatever topic is decided on the day , the last event was a really cool thing to do, learned loads. Hopefully this one will work out just as well.

25th of September - OSSBarcamp - The classic OSS event, to be held in UCD. Registration and details OSSBarcamp.

9th Of October - DDD Dublin. An event where there are a lot of developer presentations, presented by developers. The talks are selected by vote (ie not the organizers) , for more info on the series of events, please check here; the events in Scotland and Reading in previous years were really interesting , so its worth taking note of the date. I ll update this post when there is more info.

Another way of generating generic types

Mon, 26 Jul 2010 19:39:15 +0000

Kick post on Types, nothing outrageous, but this was just a construct that I never used too much.

The other day a collegue and we got stuck on a method similar to this

void DoStuff(Type type) { var iInterface = typeof(ISomethingAmazing); Type genericType = //how to get ISomethingAmazing<type>

//do more things }

and well I didn’t know but you can do this

void DoStuff(Type type) { var iInterface = typeof(ISomethingAmazing); Type genericType = iInterface.MakeGenericType(new Type[] { **type **});

//do more things }

Why would you want this? well say for example, you are working with a container and need to get all the ISomethingAmazing of whatever your type is Particularly handy if you are using a handlers or factories a lot.

What happened?

Basically we just had information about the types we wanted but at compile type we didnt know the types, this is a away to return a runtime type even when you dont know what that type is.

I hope this is helpful for someone

Cheers

When "Could not load file or assembly" happens

Tue, 13 Jul 2010 22:33:22 +0000

So I was getting an “ Could not Load File or Assembly” error, even thou I was pretty certain I was referencing the right dlls in the correct folders. What could this error possibly mean?

The actual error I had was:

System.IO.FileLoadException: Could not load file or assembly ‘Moq, Version=2.6.1014.1, Culture=neutral, PublicKeyToken=69f491c39445e920’ or one of its dependencies.

Some things I checked:

Maybe I dont have the moq.dll assembly, but it was there.
Then I checked the assembly version, my moq.dll was 4.x (the error stated 2.6.x was required), so there is a difference in the expected versions, why?
Checked all projects in the solution, all the ones using Moq.dll where explicitly pointing at 4.x
Reflector show time. I was using moq.contrib.dll on the project that was failing, and since it makes sense that such library would depend on moq, it was worth checking it out, this is what I saw

[caption id=”attachment_616” align=”aligncenter” width=”242” caption=”Reflector Screenshot”][/caption]

This means that moq.contrib.dll did indeed depend on moq, so I just needed to find a version of it that pointed to the right assembly, I was lucky because I had a set of dlls that work, if you are not so lucky, get latest from the moq.contrib google code and simply run the Build.cmd and you are all set to go (you can replace the moq.dll dependecy if they have moved on).

On the way I found some other interesting things

Like this thread, basically it said that this was possibly a compiler bug. I thought damn a dead end, but it wasn’t :).
A tool to find out how the dll binding happen callled FusLogw.exe

FusLogw.exe

Also known as the Assembly Binder Log Viewer, awesome right? :D

Where is it? I searched online and the tool seems to move a lot in differnt versions of Windows, In xp

it could be here: C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\fuslogvw.exe

In my windows 7 install I found it here: ** C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin>FUSLOGVW.exe**

Oh yeah and you need to run it from the command line as an Administrator

It might seem obvious, but you need to refresh after you run something that fails , it is, after all a log viewer

On Pair Programming

Wed, 30 Jun 2010 22:00:26 +0000

What is pair programming?

Its when 2 developers sit down together to write a piece of code. There is one person in the keyboard known as the driver and another person looking at the code and commenting about it, known as the ** navigator**, these roles can change in time. The idea is that while you are typing you are likely to catch certain things and when you are watching you are to catch other things.

Why?

I dont know if this happens to you, but many times, when I’m not sure how to solve a problem or when I have a solution to a problem that I’m not terribly happy with, I will talk to someone else about it. Then, one of two things happen: whoever I talk to gives me an idea, or as I explain the problem I realised that I missed an important piece of the puzzle and find the solution, the hidden third option is that I don’t have a solution but I have more to explore. Anyway the whole point is that verbalizing the problem, gives you a different take on it; maybe makes it more real?, as you talk you realise that certain things make no sense, you ask yourself questions. You have more visibility and clarity

Another more obvious advantages is that two brains are more than one, collaboration can get you to really far. More eyes looking at the code will at least avoid silly mistakes, in the better cases it will drive you to better design, never mind the fact that two people will know this code really well, we all know that this is really handy in a team ( we all take holidays, have days when our brains just refuse to work, etc).

When pairing , each of the persons in the pair need to be really involved, there is no distractions, ( so perhaps take breaks every hour and a half or so) this intensity means to me that its more likely that as a pair there are more angles of the problem that will be covered.

Whats wrong with it?

When people are pairing there are a few things I ve noticed that tend to go wrong

1) One way street. One of the pair is hogging the control and the navigator is quiet. This is probably the worse thing. the only possible advantage of this is knowledge transfer but I think this kind of pairing does more bad than good. One way to counter act this is using Test driven Ping Pong (see below). But education is key.

If pairing, then try to pair, not to control.

If pairing try to collaborate you are not just watching a movie.

If things are going to fast ask for slowing down, its not going to get better if you dont understand.

2)** We’ll fix it later**. This is when the pair decide to do something below standard. I dont think its a terrible practise but it does leave a “bad taste” because even when the pair decide the task is accomplished , there is stuff left t do. also there is the broken window problem.

Test Driven Ping Pong

Given a driver and a navigator, the role changes per test, say we have Alice and Bob, Alice is the driver first, she writes a test, fails, they fix the code so the test passes, goes green , they come up with some refactorings , then Bob is the driver for the next test and so on. This sounds like a good approach when the developers dont know each other well or they have an ego problem, or they dont know where to start

Informal Pair Programing

The navigator and driver roles change whenever is necessary, like when discussing stuff on a whiteboard . This is probably the best way but at the same time it requires the pair to be very involved and request changes often. I think this is more Organic(for lack of a better word) and pleasurable.

Any comments on this? i would really appreciate it particularly from people practicing pair programing often

More than a text editor

Thu, 06 May 2010 08:00:34 +0000

Recently I started using Visual Studio 2010, if you follow me on twitter you probably know that this hasnt been a nice transition for me (apologies for the cursing btw) I ve had many crashes, and I’m pretty sure I’m not alone, not only a quick search in twitter will reflect this (see image below, the only marked twitt is about a fix for something) , but a some of my co-workers had one or another problem.

It would be naive to think all the issues have the same source, and I know that many are related to the plugins ( I use Resharper with xUnit extensions and AnkSvn). What I’m trying to say is that this post is not to bash Visual Studio, to be fair the IDE is pretty flashy, shiny, even amazing…. but you know what I want options, something I can rely on and that I can bend to my will. Lets elaborate on that.

Using resharper means I’m used to using shortcuts, templates and whatnot, I know I should be able to bend an IDE to do what I want so I can code faster, be focused on what I’m doing. **On the other hand **I can also see that having a comon IDE within a group means we can share tricks and learn about each other practises.

So today I saw this post by Rob Connery and I cant help but wonder, Is Vim the right way to go?, no idea but I know I’m ready to give it another try. However Id iek to set my expectations. I think what I would like is a more modular VS (where I can turn things off).

Although it s a pain, the Add Reference Dialog **speed is not my main issue, it takes so long to add a reference that at least it makes me think “Do you really want to add that dependecy?**” I would prefer if it wouldnt happen tho.

So, what do I want ouf of my IDE:

To write code, quickly
to rely on it, if it crashes, updates, looses references that It handles it elegantly
To get feedback about the code I write quickly
yes to intellisense , I’m a terrible typist (maybe I should change that?) and it helps when you have long explicit variable names (sometimes I go overboard with this until I find better names)
to be able to change the way the code looks
to format the code to my will, even if it s stupid, I want to be able to try new things
to be able to do simple **and **complex refactorings easily and that their result is obvious before we event start the operation
good ctrl+z support
to leverage what I know, and induce me to do smarter things, after all the IDE has intimate knowledge about the framework I’m using
that I can carry around my settings (shortcuts, templates, etc really easily)

am I dreaming? Possibly, but lets see whats possible

Irish Open Spaces Coding Day II Retrospective

Wed, 28 Apr 2010 09:00:44 +0000

I think the best way to describe this is saying, When is the next one? (We think around late August, early September)

Thanks again to our sponsors: Jetbrains, Manning and Microsoft, and particularly to our hosts: the open source Lab in UCD, that place is just designed for this type of events.

Sessions:

Rx :
ook!
Cucumber with Iron Ruby
pLinq and Mono
Mongo Db (a bit of a comparison between .net implementation and a ruby implementation)

All the code for the sessions is available in our repo.

Some photos from the event here http://www.flickr.com/photos/roundcrisis/sets/72157623824914233/

FluentMigrator Composite Index

Fri, 02 Apr 2010 10:19:22 +0000

Fluentmigrator is a really nice migration tool that allows you to tear your database up and down keeping version, please visit the project page for more info.

Anyway, the other day I had to create a composite index, and I didnt know how, the way to do that is:

Create.Index(“Name_of_the_index_String”).OnTable(“Name_of_the_Table_String”) .OnColumn(“Column_Name_string”).Ascending() .OnColumn(“Other_Column_Name_string”).Ascending();

Looks kinda obvious no? but what threw me off at the time is that I was looking at the possible operations after OnColumn and there was nothign obvious there,

then I looked at the Sql documentation for CREATE INDEX

CREATE [ UNIQUE ] [ CLUSTERED | NONCLUSTERED ] INDEX index_name
    ON <object> ( column [ ASC | DESC ] [ ,...n ] )
    [ INCLUDE ( column_name [ ,...n ] ) ]
    [ WHERE <filter_predicate> ]
    [ WITH ( <relational_index_option> [ ,...n ] ) ]

The solution was (kind of) there, you could do more columns after you specify the sorting direction. Perhaps it’s obvious but it took me a while to figure out. It was logical however not obvious.

Also on composite, before I created an index I thought about using composite keys, J.Miller has a post here on why that is not really a good idea ( have a look at the comments in particular). For me, it boils down to:

Maybe something that has meaning now, wont necessarily have the same meaning in the future
It’s harder to manage composite keys that it is to manage surrogate keys

There are more reasons for and against surrogate keys, but this was what was suitable to me at the time

Cheers

Ada Lovelace Day 2010: Amanda Laucher

Sun, 28 Mar 2010 08:57:39 +0000

I’m late with the Ada Lovelace Day article, I had the choice of making it on time but incomplete, or put some time and be late, and I chose the later this time. I really though the person and the topic deserved in depth investigation.

I didn’t really know how to approach the Ada Lovelace Day last year and this year I still don’t know now, I think the best homage I can do is learn more about F# in this case.

This post is about Amanda Laucher and about F#. Amanda is the author of F# in Action. A speaker and most importantly a software developer, when you see her talking you can see she really likes what she does, and that fact is pretty inspirational.

I found quite a few of her presentations online

QCon London 2010 - Pragmatic F# in Action
QCon London 2009 - Concurrent Programming with F#
Channel 9 - 2008 Ted Neward and Amanda Laucher on F#
I’m sure there is more but that’ll get you going =)

Then I also found some other F# resources

Wikipedia had a pleasant surprise in store for me with a really comprehensive introduction to the language, and also pointed me to a wikibook however when I started typing the code and trying to run it I ran into problems because the parser looks at line breaks.

Disclaimer: I never done any f# before so anything below could be completely wrong (if so please let me know so I learn :) )

In a short time I learnt that

F# is

Not purely a functional language, some OO aspects and has type inference.
a strongly typed language
.Net language
has Garbage Collection
does Lazy evaluation ( this is really cool )
Some sort of Asynchronous workflow ( need to digg deeper on this)

More detail

Everything is immutable by default, but there are mutable objects ( apparently the objects that you can get by interoping with, say,a c# dll are mutable but I’m not sure)
lazy evaluation
Asynchronous Workflows
You can pass functions as result of function executions, or be the result of functions, and have functions inside functions
Send parts of parameters into a function
have a collection of functions that can be started asynchronously (holy smokes!)

After looking around I also found some good videos from Erik Meyer on the topic, hes got a series of them you can have a look here, the series goes through the history of functional programming and principles, very interesting.

I can see a lot of potential on this, I find functional programming a big mind switch and I’m sure it will take me a good while to do it properly, however, the goodness of looking at this code comes from the ideas you can take from different approaches.

One thing that did strike me so far is that i ve seen bad variable names and no unit testing on it at all, on the other hand, the power that you seem to suddenly have is just incredible, tho since the paradigm shift is so big, I found myself stumbling and not being able to do things that i find really simple in c# (like print an array to the console, the difficulty was on realising that the line breaks are significant)

The real life example from the QCon talk from 2009 was a really good way to see the value of the language as real life usage, the QCon talk from 2010 was really good because it dived deep into the language, language usage, etc.

I feel like I’ve started learning something that will change the way I code and I’m really happy about that.

Irish Open Spaces Coding Day II

Fri, 19 Mar 2010 13:00:03 +0000

Hi all:

Just thought I d post here that a group of us in Dublin. Alt.Net are organizing a coding day the 24th of April in UCD, it should be a fun day of hacking some code. One of the really cool things is that James Gregory will be there talking about Fluent Nhibernate.

If this sounds like something you d’like to do you, can register and find out more about it in codingday.org

Cheers

New/Swiped Development Machine - software musts

Sat, 13 Mar 2010 14:20:25 +0000

I understand the title makes little sense, but this is probably what I would search in a web search engine ( hopefully at the time I ll find my own post) A short, unordered list of things I install when I get a new machine/wipped machine

An FTP client Filezilla will do
Firefox + Add on: firebug, noscript, colurful tabs,
Chrome ( for js intensive stuff it jsut renders faster)
ieTester ( run multiple ie versions parallely)
ieDebuger
Wireshark, comes handy
Reflector
Resharper
Syntax friendly Notepad ( I use Notepad ++ but not mad about it)
Tortoisesvn or Anksvn
Tortoise git
SVN Monitor
Git ( you ll need it at least to download libraries code)
foobar2000 music player ( after all you need to block the noise from the outside)
Sql Server Management Studio , you ll eventually need it and if you have profiler you ll probably need it too
#Develop is kinda handy too
I use Evernote, so I would install that, tho not run it often just because I don’t like the desktop client much tbh
Sumatra PDF (if anyone knows a better one I d appreciate it)
Visual Studio
Setup IIS

DDD South West

Sat, 06 Mar 2010 09:00:23 +0000

So there is another DDD event the 5th of June, and this time is in Bristol, call for speakers is on ( if you want to submit, you can get instructions on how to do so here)

Sessions look interesting so far.

I really enjoyed the last DDD in Reading, Uk.

The Art of Unit Testing - Review

Mon, 15 Feb 2010 07:39:04 +0000

A few of us have been reading this book as a part of a book club. Finally I think is time to push a review for this book .

Let me start saying that my expectations for the book were very high, the book club helped because we were really reading it in depth and going over little bits of each chapter.

Bad things about the book

Examples are not great, there are errors on some of them, and (possibly the worse thing of it all) some of the tests dont follow the advice that is given in the book, particularly in naming convention.

If you download the code that accompanies the book, some of the tests (that are supposed to pass) fail.

We sent an email with corrections but never heard back ( not sure if they didnt get it or what), which, to be honest, was a bit disappointing, if this code was on github I would have forked it just to get it fixed, tho I’m not sure Is correct to do that if the code is not on github (if anyone knows please let me know).

Again on the code samples, some of the examples scenarios are not really that descriptive, I have to add, that after preparing the talk I gave in DDD, I have to say its really really hard to come up with good sample code, that demonstrates a smell and a solution in a clear way in not a lot of code… so maybe its not a fair criticism, but I really had to mentione it, because you read the sample and really **wtf? **a bit .

The chapter on Mocking is not great either, Rhino mocks is not used in anger, and I’m pretty sure Roy could have gotten someone with loads of experience in Rhino Mocks to look and review (and improve ) the example code.

Good things about the book

I know that after what I said what bad in the book, this will sound fake, but I actually think the book is really good, because I learned loads about unit testing.

It made me think about how to test, What to think about when testing, how to approach writing code with testing in mind.

It basically gave me a lot of basics like, the difference between Unit and integration tests, and that was important, because I could clearly define, I need to tests **this **(whatever it is you are writing) I understood the differences between different Fakes, as well as the difference between state and behavioural tests.

Along the way, you pick up on test smells, and many tips on what to do and most important, what not to do.

Since I read the book I understand and I have the purpose of writting code ( test code included of course) , that is readable and maintainable. And I want to **trust **my tests, and thanks to the book, I can now understand why these are important qualities of the code.

The funny thing is, that since then, I actually feel like I really got how to be test driven, because writing code in any different way, simply doesn’t make sense any more.

Conclusion

A really good book if you are interested in unit testing and feel the need to learn how to do it better, like anything you read, take it, use what you can and completely believe in and then, discard the rest; even then you will have about 80% of the book (or more) really valuable.

Reading this book, along with TDD by example by Kent Beck and maybe completing it with xUnit Test Patterns byMeszaros

Push on Green Deployment - (Brain Dump)

Fri, 12 Feb 2010 01:02:01 +0000

The other day I was listening to Kent Beck in this podcast where he was talking about, amongst other things, push on green deployment, basically the idea is that once your test suite goes green, you deploy.

When I heard this originally I thought :

1) Think about all possible problems -> not only technical( this component is not compatible with the component just rolled out, etc, etc) but also processes ( and people using them ) this is a real concern, because the pace of change would increase I would guess)

2) What tests? Who wrote them? I would think higher level tests? actually all tests? Possibly the upside of this is that companies that produce quality software will become incredibly popular ( “My software doesn’t brake, we test throughly” could actually be part of the marketing and backed by actual tests, imagine that)

3) The premise for push on green is basically to push Software Development practices up a notch, so that as a developer we can say we are delivering a feature on a particular date and we can do that confidently, How does push on green help us deliver as we promised, would it makes us slower?

Deployment is a painful process, and often neglected topic, as a developer how often do you think about it? And worse, How many times you just don’t know what will happen? Most importantly. How stressed do you get close to going live? (I guess this is the time when we all start thinking about it seriously)

Great, now imagine What if that would happens every hour?

In the beginning it would be scary, but then, the practices need to be polished enough so it becomes something normal, that you are not only used to , but confident about it. After all we all become better at things with practice.

Do i like the idea? Yeah! and Its as scary as it gets :) Lets look into it more in depth

So how can this possibly work?

If I was going insane(er?) and really wanted to do this, as a C# developer, what is possible?

Maybe I would start of an continuous open beta or, edge (somehow warning my users of the fact that the code they are using is “fresh out of the oven”) and once I see some stability (perhaps people could vote for it or similar)then I can fully deploy.

But then thats is just my application, lets imagine I produce code that is not public facing, but that , its an API, consumed by many other applications, how would they be aware and react to interface changes? More importantly, would this make software evolution slower by persisting everlasting APIs? or would it induce APIs that are very noisy, hence harder to discover?

I’m asking this because: lets forget about the barrier of web or desktop for a minute and focus on dlls, where they live and how we use them and consume them.

If my Operating System vendor/framework provider makes a push do i want my app to get that immediately?

Say I’m using an interface something like IEmailSender, that has the methods Send(IEmailTemplate, ISomethingElse) and that is replaced for the better designed IEmailSender.Send(Message) with the Send(Message[]) overload. In that example I agree with the change, I want to use the new code because the contract is better (lets assume we all agree is better ok); however, that would mean changing my application, re testing all those areas where I use IEmailSender and I most likely don’t want that.

I have to add, I would probably want to do an integration test anyway, or should I blindly trust the new IEmailSender implementation because we are all pushing on green now?

So the option here seems to be, create the new contract but maintain the old one around for a while right?, but then your API will have all these Send methods, and that doesnt seem to be going into the better development practices direction

Next I’m gonna try heroku in anger and see if I get more ideas from using it, heroku is a service that runs ruby applications that are deployed when you commit.

This is a brain dump on this and would love to hear thoughts from other people, corrections, feedback, etc always welcome :)

Test Class Organization

Tue, 09 Feb 2010 21:29:05 +0000

Hi there

Just though I d share this

this is the way I ve been organizing my test code as of late

	public class MyClassTests
	{
		public class Given_a_context
		{
			[Fact]
			public void When_somthing_happens_Then_result()
			{
				throw new NotImplementedException();
			}

			//...............
		}

		public class Given_a_different_context
		{
			[Fact]
			public void When_somthing_happens_Then_result()
			{
				throw new NotImplementedException();
			}

			//...............
		}
	}

I like this because you can still easily find the class name with resharper you can also separate the contexts you are testing in a more clean way this works out good for me most of the times, even when you are inheriting from a base test class. It also reads well in the Test runner. Any comments?

Lessons Learned in Unit Testing Session - DDD8

Sun, 31 Jan 2010 22:55:41 +0000

DDD8 was a lot of fun!

I really didn’t know what to expect and it turned out great, and got to a few talks ( not as many as I wanted tho) and met personally a lot of really interesting people.

Moving on swiftly to the meaty bit of the post:

I’ve uploaded the code and slides to github, I’m hoping I can improve this samples with time, if there is anything wrong apologies in advance, first time using git as a committing to a project so I’m bound to get it wrong. Looking forward to James Gregory E-Van on git so I can learn more on the topic :).

I’m sure I ll look at the code sometime later and think OMG! how did I dare to present this in public, but I guess is the nature of the beast :).

If you saw the talk please let me know what you think, as I would appreciate any feedback, particularly the parts that I can make better. So far I the feedback I have is:

I do speak too quick,
I should talk about legacy code and how to deal with that

I posted the code in the same way I presented it, this means there is a OrderService_version1, 2 and 3, hopefully you can follow the code pretty much as we did it in the talk.

There was some questions, and I said I ll post some links here:

Books:

The Art of Unit Testing (Roy Osherove), the talk is heavily inspired by this book
xUnit Test Patterns, Refactoring Test Code ( Meszaros), Great book if you are looking for more detail. Perfect as a reference book

- TDD by Example by Kent Beck, a very hands on approach highly recomended.

Working Effectively with Legacy Code, Michael Feathers - A must read if you are interested in testing (whether you are working with legacy code or not).

Tools:

During the talk I was using

Unit testing frameworks:

-xUnit

-nUnit

Mocking Frameworks:

-moq

Other tools mentioned:

-Rhino Mocks: Possibly the most used Mocking Framework

-NCommon: General purpose library, definitely worth a check

-Ninject: IoC container ( there is also .. Ninject.MVC that helps you wire up the dependencies of your controllers on they fly, very useful )

-Windsor: IoC container

If there are any questions or comments, please do let me know

Thanks to the organizers and everyone there, it was a wonderful experience that I’m hoping to repeat.

Cheers

Step by Step StarterSTS Setup

Thu, 17 Dec 2009 21:30:51 +0000

I’m planing on a series of blogs on WIF ( windows Identity Foundation) however that might or might not happen :), so meanwhile I m posting this, StarterSTS is as the name implies a starter sts something to get you started on the world of Federeation Identity , claims and all that lovely stuff.

You can find a video about all this steps in the codeplex site to starter STS, however there are a few differences between what you can see in the config files there and whats in 0.95 ( this is what I’ve used) .

I tried this on a Windows 7 and a Server 2008 machine

1) Get the sources from codeplex and copy them over somewhere. create a web app that points to it 2) Create a new app pool ( not necesary but nice to be able to see what is happening) 3) Install WIF (used to be called geneva framework) latest binaries available here 4) Download and install SQL server express,or if you have a ssql server there happy days :D 5) Create a self signed cert and add it to the default web site , then go to default website and add the certificate to https with Bindings options 6) Add read access to the Network service account in the folder where you put the sts sources 7) Run mmc -> add snap in and get the cert thumb print , also set the network service read permisions by right click Manage Private Keys… 8) Open the file config/Certificates.config and change the thumbprints of the certificates ( initialliy they are all the same , the last one RP, should be the thumbprint with all spaces removed) (you can get the thumbprint of the certificate in mmc ->certificate ->properties -> thumbprint) 9) Run aspnet_regsql ( to create the asp.net membership provider aspnetdb) (This program is not in the path, so you ll probably have to go to C:\Windows\Microsoft.NET\Framework<your version of the .net framework, if in doubt go to 2.0»aspnet_regsql ) 10) Create some users from IIS Maanger. 11) If you are going to be using from somewhere other than localhost:

The self cert you provided must be added to your the trusted providers( whereever you are using this)
when you are using fedutil make sure teh references to the federationmetadata.xml points to your server and not localhost ( i seen this happening more than once)

12) On the application side of things Add STS reference… 13) you might need to tweak the startersts.Config

Using Ninject and Asp.Net MVC

Fri, 30 Oct 2009 10:38:18 +0000

If you are trying to use Ninject with Asp.net MVC, there is an integration available in github http://github.com/enkari/ninject.web.mvc if you look at the code there its just 3 clases, but the fact that its been used by much more people than just myself makes me a bit more confortable because I’m not terriby familiar with Asp.Net MVC. Please note I’m not too familiar with Ninject either If there is anything that can be improved, I’m all ears.

Anyway, this is the integration working, using Ninject 2, I tried this with MVC 1 and 2 and they both worked.

Obviously get the code from the Github repository and build the solution in release mode, add them to your project.

Then in your Global.asax.cs you need to do your implementation of CreateKernel, and a really important step, to register all your controllers, to do that just override the OnApplicationStarted with RegisterAllControllersIn("SomeAssemblyName") as in the example there in github.

If you are not familiar with ninject you ll need to look at defining your Modules as well, something like

    private class MyWebAppModule : NinjectModule
    {
       public override void Load()
      {
          Bind<ISomething>().To<Something>();
    ......
      }
    }

Oh yeah, for some reason, kernel.AutoLoadModules() doesn’t work for me, its not a feature I’m interested in at the moment but …

and you can use that module to create the kernel, there are other ways to use Modules but that worked for me on my todo now is to understand why you would use one way over the other to create and work with modules and what modules actually are.

Ext Js bits

Tue, 20 Oct 2009 19:00:54 +0000

Just some interesting thing I found on the extjs world.

I’m only looking at stuff working on ext3.0

In ExtJs the JsonStore has paramNames this Object contains 4 properties

    {
        start : 'start',  // The parameter name which specifies the start row
        limit : 'limit',  // The parameter name which specifies number of rows to return
        sort : 'sort',    // The parameter name which specifies the column to sort on
        dir : 'dir'       // The parameter name which specifies the sort direction
    }

This properties are the default however they can be changed by using a configuration property or to change globally it should be changed in the store prototype

Drag and Drop into a grid

Shea Frederick has a very nifty Excel drag and drop into the grid, got the code and runs in ie7, ie8, ff3.5 and Chrome and you can get it here

Barcamp Derry Presentation

Tue, 13 Oct 2009 22:49:48 +0000

Had a brilliant weekend up North in @barcampderry Met some interesting folks and had a chance to discover a fantastic city and the surrounding area.

As promised these is the slide deck for the presentation, I don’t think these are of much use but please feel free to ping me on twitter or as a comment here if you have questions or comments.

[slideshare id=2213304&doc=oss-091013174416-phpapp02]

Cheers

Thoughs on 1st Book Club meetup

Wed, 16 Sep 2009 19:33:47 +0000

The Art of Unit Testing (by Roy Osherove) First Meetup

Its amazing how much you can talk about just one chapter, ok we diverged at some point to related topics, we dreamed about our own Open Source project, again. Anyway, these are my thoughs about the first chapter, after the meeting

Integration testing and unit testing: I end up thinking:

You shouldnt do it inadvertedly.
Its your responsability as as developer to do certain Integration tests (if you want to make sure that certain services are working as expected, that certain dependencies that you have and you are ok with that are working as expected)

We also mentioned the Demeter Law when talking about building APIs.

Again this inspired me to look at StoryTeller. Some resources I found:

Jeremy Miller’s post about it
Elegant Code Podcast
InfoQ Post
Channerl 9 Podcast

I’m now looking at the samples from it but that ll be in other post :)

The Art of Unit Testing - Chapter 1

Wed, 09 Sep 2009 09:35:55 +0000

We are meeting for the first time for the Book club and just to get the ball rolling on this I though I’d write up a mini summary of chapter 1 on The Art of Unit Testing before the meeting as a way to explore the concepts and then another one after if necesary.

So far I like the book, a very clean and concrete explanation of the basics, in plain english.

Some concept definitions are opinionated, but Roy does a good job of it by telling you that there are many defintions available of certain terms, he then tells you wich one he will be using, for example when he defines Legacy Code he setteles for: Code that has no unit tests ( in line with M Feathers), he gives you a few other options including one that kept sticking in my head: Code that works. (quite possibly with bugs , I cant help to add).

He makes a lot of emphasis in Good Unit Tests, as tests that are automated, repeatable, easy to implement and read, that are trustworthy and run quickly, normally written using an unit testing framework.

I think a knock on effect of this is that the tests will be just a few lines long and quite likely many.

The definition of Integration Tests made me think a lot. For reference: Integration testing means testing two or more dependent software modules as a group. I’d really like to discuss this with the group tomorrow today, I’d say many of us do more Integration testing that we tend to think? particularly if we have a dependency on a service that has no other hard dependencies ( like a db, I/O operations or similar) – Will update on this.

Another good concept to be introducing at this early stage is the Regression, and when I was reading this I was thinking It’s so great to tie this up with CI, why? Well if you have relevant test coverage and you change something (adding the required unit tests and all ) you commit your code , the build machine will immediately go and try to build and run your test suite, so that will help you to know if potentially you have a regression.

He outlines a series of questions to ask yourself to find out if you are writting good tests the one I liked the most is this one:

Can I write a basic test in no more than a few minutes? – Will update on this too later on.

There is a unit test example without using a framework, I liked it first because of this little snippet that I didnt know about: MethodBase.GetMethod().Name , more to the point I think hes trying to highlight the advantages of the frameworks and also because it reminds you of the fact that you dont need unit testing frameworks.

Then there is a basic intro to TDD, where the last D stands for Development , and thats ok, I have not much more to add because I didnt find anything that sticks out .

So far so good, I think we could have jammed the first two chapters in this meet up.

Comments, corrections and questions as always welcome :)

Meet ups Conferences Visitors

Mon, 24 Aug 2009 11:21:42 +0000

Very excited by a very very busy few months ahead:

This wednesday thursday and Friday Epicenter, In dublin where John Skeet, Craig Murphy (the man behind the DDD events), Barry Dorans, Barry Carr and many others will be talking, including me :) . Sounds like a busy conference full of choices.

Oh yeah! and Craig Managed to get a Special Offer on Epicenter, buy 1 day get 3. More here

September Dublin Alt Net meeting. 15th of September. New location Seagrass we ll be doing some lightning presentations on Kanban, Mono and Fluent NHibernate ( a bit of a mixed bag) more details to follow in dublinalt.net
OSSBarcamp, this is one not to miss, the 19th of September all things open source. One talk I’m particularly interested in is the one on IPython, I really hope I can make it at least to that talk.
Finally the 30th of september Sebatien Lambla istalking about Open Rasta , finishing arrangements as we speak, this is the first urregular Dublin Alt net meet up =). Location will probably be Seagrass too. More info to follow in Dublinalt.net

Cheers

Format(ing) in GWT-Ext

Fri, 14 Aug 2009 11:31:07 +0000

Just a quick post :

If are trying to use Format, in GWT, String.Format is not supported, instead you should use Format a lot of interesting stuff there, so if you are using GWT-Ext take 5 min of your time and have a look, you ll end up using it.

This is what I’m using for Strings and for dates

Nvelocity help

Wed, 05 Aug 2009 13:41:02 +0000

Hi there

I ll just add this because I saw some people being directed to here when searching for NVelocity docs (no idea why tbh)

Anyway here is the link to the Appache documentation for velocity

Also of course the castle docs

August Girl Geek Meetup

Mon, 27 Jul 2009 13:56:27 +0000

This coming Wednesday the 5th of August we are going to be meeting up in Kennedy’s ( nearly opposite to Pearse Dart Station) Its been a while so I’m really looking forward to catch up with the girls. More info here Hope you can make it if you are a Girl Geek =)

Cheers

IronRuby - Some Resources

Tue, 07 Jul 2009 11:45:09 +0000

I found some interesting IronRuby Resources that I thought some people might find useful:

http://blog.jimmy.schementi.com/ complete Articles on Iron Ruby, I think he is somewhat related to the IronRuby project ( never really read the profile, just the articles….)

http://flanders.co.nz/ Blog from Ivan Porto Carrero, the Author of Iron Ruby in action ( its on EAP from Maning).

http://blog.benhall.me.uk/ Ben Hall’s Blog. He s got some really complete articles in that blog, and a really good speaker. He wrote this article on IronRuby and RSpec on the MSDN magazine.

http://www.ironruby.net/Documentation Of course :D

http://www.iunknown.com/ John Lam, I believe he is responsible for this project, however he doesn’t blog too often.

Valid xtypes in GWT-Ext

Tue, 30 Jun 2009 11:19:11 +0000

Say you have a panel, that contains a form and you want to get the values for the fields of that form, one way to go on about it is to use findByType():

Find a component under this container at any level by xtype.

Parameters: xtype - the components xtype Returns: an array of components this is all well and good, however the available xtypes, what are those?

A bit of magic string here?, what are the available xtypes?

You can find a list below: `

xtype Class
box BoxComponent
button Button
colorpalette ColorPalette
component Component
container Container
cycle CycleButton
dataview DataView
datepicker DatePicker
editor Editor
editorgrid EditorGridPanel
grid GridPanel
paging PagingToolbar
panel Panel
progress ProgressBar
splitbutton SplitButton
tabpanel TabPanel
treepanel TreePanel
viewport ViewPort
window Window * `

` `

`* Toolbar components

toolbar Toolbar *
Form components
checkbox Checkbox
combo ComboBox
datefield DateField
field Field
fieldset FieldSet
form FormPanel
hidden Hidden
htmleditor HtmlEditor
numberfield NumberField
radio Radio
textarea TextArea
textfield TextField
timefield TimeField `

This list is available from the** Component** class in the package com.gwtext.client.widgets;

As a cleaner way to deal with this I created an Enum to work with this information.

Hope it saves you 10min.

Ext-GWT(or GXT) Environment from scratch

Mon, 29 Jun 2009 09:26:43 +0000

So… I had to set up a GXT development environment for myself from scratch, so I thought I d share the experience.

Getting the JDK was painfull

I ll spare you the rant, however I will say that Sun requires that you are registered to download the JDK, after a email like the one below: ` We’re sorry but your Sun Online Account password could not be reset.`

` `

We would be happy to look into this further for you. Please forward this email to us at login@sun.com. We apologize for any inconvenience.

a 404 ( see screenshot) and a failed attempt to re- register, I ended up getting the JDK from another machine, via remote desktop.

404

JDK, check

Ant

Next thing on the list was to get ant, I went to the appropriate website got the binaries, un-zipped, set the ANT_HOME, and proceeded to add ant to my path, checked that the version was the correct one with

` ant -version` and all fine

ant : check

Installing GWT

Then i went to get GWT , downloaded, unzipped, added the GWT_HOME (not required but handy) then ran the mail sample in hosted mode as described in the GWT documentation getting started win ant deploy

Creating a project with GWT 1.6.4

A lot has changed since version 1.5.3 the two more obvious things so far are: speed running the hosted mode, the layout of the project files, and the application creatorand now you have to use webAppCreator.cmd (extension depends on your platform of course) , then, since I use eclipse I can jsut import the project and start working with it, tho I wanted to try GXT .

Installing and using Ext-GWT (or GXT) 2.0 RC1

GXT 2.0 required GWT 1.6.x ( I’m using 1.6.4) , at a glance, there are a lot of things that make GXT look really good, like active development and a roadmap :D, some new widgets, support plans, etc.

There are a few steps required to make GXT work in the project I created in the previous step,

Copy the Resources folder into the project war folder (you could call it something else but I dont see the point yet), then, as described in the setup.txt,
Add the stylesheet to the host page html
Add the <inherits ..> to the ..Gwt.xml,
Include the gxt library to the project classpath
and include to the Launch configuration.

To check that this is a GXT app we write a bit of code on onModuleLoad method:

Button button = new Button(“Click here”);

ContentPanel panel = new ContentPanel();

panel.setTitle(“GXT Test”);

panel.setHeight(400);

panel.add(button);

RootPanel.get().add(panel);

gets me something like:

Task Completed. Next task, get a basic layout with a grid populated by JSON.

Button button = new Button(“Click here”);

ContentPanel panel = new ContentPanel();

panel.setTitle(“GXT Test”);

panel.setHeight(400);

panel.add(button);

RootPanel.get().add(panel);

Gwt-Ext Hack FormPanel and Panel

Thu, 25 Jun 2009 08:00:04 +0000

There seems to be some sort of problem when you have to add a FormPanel to a Panel in GWT-Ext 2.0.6.

As a workaround you can simply use a Panel and set the layout to FormLayout.** **

**Hope it helps **

June Meetup Alt Net Ireland Review

Wed, 24 Jun 2009 10:46:40 +0000

The past 18th of June we had a meetup.

This month’s meetup topic was Behaviour Driven Development presented by Claudio Perrone and Andre . It was an overview of the topic and how does it work as well as some examples with cucumber , Andre is a QA Professional and himself and Claudio demonstrated how they collaborate. Andre is involved in the Development process from early on and uses cucumber with Selenium and Watin (or Watin not sure).

Edit: Andre did a blog post about it (you can see it here)

Then we decided on July’s topic: IoC facilitated by Franklin (Windsor) and I think someone said they will bring some StructureMap samples for a discussion, sounds good.

I really enjoyed the last few meetings and I hope it keeps happening.

Claudio will not be attending a few meeting as hes going to be busy looking after his new born, Best of luck for you and your family. We promise to keep you posted and hope you come back soon.

Cheers

GWT Unit Testing

Tue, 23 Jun 2009 11:12:13 +0000

After some time messing with GWT-Ext

I found a few problems on this front:

running the test takes too long ( I’m writting this post as I wait for the tests to run) , for example to run a test like the one below, takes 10 seconds, and that is after you ran the whole suite, a suite with 23 tests takes aproximately 100 seconds… not great tbh. ` Dog dog= new Dog(); int legs= dog.legs.length; assertEquals(4, legs); int eyes=dog.eyes.length; assertEquals(2, eyes); `
A convention that i dont particularly like ( perhaps because I’m not familiar with it) is that the test methods must start with **test, ** ok , on the plus side you dont have any attributes lurking around.

**- **Then there is the obvious problem: you can really only test certain code, ie things like parsing , etc is all grand, however when it comes to testing that certain controls are there , it becomes very cumbersome.

However, i rather have some unit testing than none.

If you have any experience testing GWT-Ext I would really love to hear about it.

IntelliJ IDEA keymap for Eclipse

Tue, 09 Jun 2009 08:50:38 +0000

I’m seriously used to the Resharper key map in visual studio, so when doing Java development I felt a bit handicapped, unfortunately I cant use IntelliJ IDEA (did the 30 day trail and loved it) so after a quick google I found this. Its not perfect but it works.

GWT-Ext ComboBox loading from XML

Tue, 09 Jun 2009 08:41:36 +0000

This is a simple example on how to make a ComboBox in Gwt-Ext to populate with XML.

HttpProxy proxy = new HttpProxy("xml/combo_data.xml", Connection.GET);

final RecordDef recordDef = new RecordDef(new FieldDef[] { new StringFieldDef("id"), new StringFieldDef("value") });

XmlReader reader = new XmlReader("comboitem", recordDef);

`final Store store = new Store(proxy, reader);

ComboBox combo = new ComboBox(); combo.setLabel(“Combo Label”); combo.setStore(store); combo.setDisplayField(“value”); combo.setMode(ComboBox.REMOTE); combo.setTypeAhead(true); this.rootPanel.add(combo);

` store.load(); ` And the xml can be seen here

Hope it helps

Monorail in IIS 7.5 (windows 7)

Sun, 31 May 2009 13:23:56 +0000

So I made the leap the other day and installed RC for Windows 7 and it all seems pretty ok.

Of course i had to do the install all I need dance.

Making monorail work in this new version of IIS…well I just thought I d blog about it as it didn’t work “out of the box”.

One (obvious) thing that you have to make sure you do is that you actually have asp.net and the ISAPI module installed (its not by default).

The Virtual Directory needs to be an Application, for this you have an option for SetAsApplication in IIS in the contextual menu for the Virtual Directory.

IIS 7 has classic and Integrated mode, a very basic difference between these two modes is that in classic mode Asp.net was integrated into IIS via the ISAPI Extension, with the integrated mode asp.net runs natively, to read more about it check here. That leaves me with the question of: Does that mean my app doesn’t actually need ISAPI at all (that i will answer later, tho probably not).

All that said and you have to add the following to the web.config in system.webserver -> handlers

<add name="MonoRail" path="*.rails" verb="*" type="Castle.MonoRail.Framework.MonoRailHttpHandlerFactory,Castle.MonoRail.Framework" preCondition="integratedMode" />

` `

(of course change the handler to suit your self)

I have to admit, dont find setting up servers entertaining at all.

Hope it helps you.

Cheers

GWT-Ext Charts

Mon, 11 May 2009 10:48:17 +0000

A quick post about Gwt-Ext Charts.

Getting charts to work in GWT-Ext can be a little painful.

There is 3 things you have to make sure you have:

1

in your .gwt.xml

2

the gwtexux.jar file in your classpath, and of course the jar file should be wherever you are pointing to ;).

3

Most importantly the swf file that is on wherever you set your express install, in the demo is set to ` chart.setExpressInstall(“js/yui/assets/expressinstall.swf”); ` and even tho i had my library where it should, for some reason for me it wasn’t uncompromising to the right path so I uncompressed what i needed to public/js.

Note: Sometimes the charts don’t actually work on hosted mode, so you should compile/browse and its there … in Firefox and Chrome but of course it doesn’t work on ie :(, this is depending on the version of flash you have.

Scrumy

Mon, 04 May 2009 23:16:22 +0000

Quick post about this little board app. Say you are doing agile and you have the board with cards, why do you need the physical board? head to scrumyhttp://scrumy.com It s very simple to use and no signup required (love that)

Even at a glance I can see I would miss some things, however It could prove useful to you.

I got to see this because the masstransit website has a link to their scrumy .

Developer Developer Developer Scotland

Mon, 04 May 2009 19:18:01 +0000

After a very fun DDD Belfast I was debating,whether I should go to Developer Developer Developer Scotland, in the end I did and it was a good decision. I had a great day and a great night talking to other geeks.

I got there a bit late, flight+train + walk+ getting lost in the campus, however I did catch the tail of the Refactoring presentation by Gary Short I was curious as to how Refactor and other Dev Express tools look and work.

Then I went to a talk that I was quite looking forward to: Embracing a new world - dynamic languages and .NET by Ben Hall, he started of by presenting ruby and then IronRuby, then he moved on to show how you can use ruby and .Net by creating a sample wpf from the command line with very little code, then came what I think was the best part of the talk : that joke about Gary Short writing IronSmalltalk (hehe just kidding), the best part of the talk was when he showed how to use Iron Ruby and embedded it into a program, there is an article about it here, what that means is that basically you can get to use ruby syntax within you app, I find that really powerful. He also talked about rspec and Rails and how .net developers should be checking these frameworks out, I agree on this, particularly for testing, I hope to see more talks on this subject.

Then I went to Sebastien Lambla’s Asp.Net **MVC** best practises, were he talked about how to modify Asp.Net MVC default behaviour and project, to make it better with more SoC, implementing some healthy conventions,etc (I ll update this post with the slide deck when/if it becomes available) . What sticks in my mind at the moment is the way he was using a Model for each view. He was also using Windsor heavily and I think he did a fantastic job explaining what it is and how to use a container. Another thing I liked was that he refereed to a God Object, I think we all know what that means and why it should be avoided, great way to describe it tho.Kudos to Seb for bringing up the GaGoRuCo incident and added images of naked man in the slides :) . Extra bonus points for mentioning castle Monorail.

Then it was lunch time and there were some Grok talks, I was just in one of them about Sharepoint, the presenter ( I’m afraid I dont know your name sorry) was showing how to use Typemock to do Sharepoint development. I’m sure it helps not to have to depend on having the server in your machine, fair play.

After lunch I popped into Barry Carr’s What is Functional Programming? **really good talk, it quickly immerses you in the world of Functional Programming, How it started, the history, the principles and then some code with **Scala. Many of the concepts that are available to Scala ( and used in functional programming) are not alien, its how you use this concepts that is different, Scala is ,of course, designed for this, hence the syntax is better for it. Liked how Currying is implemented, want to look into Actors a bit more.

To finish of I went to: AOP with Castle Windsor and PostSharp by Chris Canal, Chris presented the principal concepts of AOP and then moved on to samples. First with castle and then with PostSharp. He started with the Runtime Weaving using castle (Windsor and DynamicProxy2) , then he moved on to postSharp to show compile time Weaving. All in all good intro into Aspect Oriented Programming.

Then we went on to a Geek Dinner, it was great to just talk to everyone and the food was really nice. I had a fantastic time, learned loads, met some really interesting people , so I consider the trip a complete success. Thanks to Colin, Chris and everyone organizing this event.

Webby - simple websites made simple

Tue, 28 Apr 2009 13:24:40 +0000

My dad asked me to help him do a website, so I started looking at the options, I definitely do not want to maintain this at all I thought.

He said: I just want an info page.

And I though about Ana Nelson and her recent talk in Ruby Ireland about how to regenerate documentation[update: jsut been to her site and she moved her blog to webby :D], so 15 min ago I was trying webby, and its great, its a framework that does exactly what a framework should do: save you time but does things properly.

From my 15 min experience I can see that Its super easy to use, It generates a web structure quickly, it’s template based and does loads of smart things for example:

In the css you can define “variables” with, for example, colours ( always thought this was necessary but also I think variables shouldn’t be implemented in the css definition)
you can output to other formats ( in my case pdf output is really handy )
goodness. Because Webby is a wrapper around rake, you can simply deploy to a site server

I ll see what else I can use, but I really like it because it allows me to do something I’m happy with very quickly and that means that I’m actually waiting for my dad to send me the pictures and remaining content so i can deploy this site :p.

Also it gives me room to add some eye candy, I was reading this related post and really liked it too.

Monorail Sample code - NetTwitt

Mon, 06 Apr 2009 12:01:11 +0000

Hi all:

During the previous two weeks I ve been presenting “An Introduction to Monorail” in Belfast for the Developer Developer Developer Belfast and in OssBarcamp in Dublin, I said I would make the sample code available and here it is.

The application presents a simple Twitter application, user can post a twitt, user can follow other users.

This sample uses Monorail, Active record, NVelocity and Windsor integration.

The slides are in the previous post, the code its now available from here

Please note, if you go to the trunk you ll see a folder called GettingStartMonoRailAndActiveRecord, a hello world for Monorail (using Brail) and Active Record written by Chorn Sokun, then you can find** NetTwitt**, the code that I used for the presentation. I believe it was a good idea to put both together, so if you are getting started you have more to look at.

You should simply get the trunk, open one of the solutions, hit F5 and it should run (on Cassini)

If you have any questions or comments please let me know so we cna do something about it

Cheers

Andrea

Monorail Presentation Slides Updated

Thu, 02 Apr 2009 08:46:11 +0000

Hi all

I have updated the slides for the monorail presentation as follows (There are 23 slides if you see less it means there is caching somewhere along the lines, get them quickly here)

[slideshare id=1212832&doc=monorailintroduction-090327185816-phpapp01]

Comments, questions and typos all welcome so they can be corrected.

Cheers

Developer Developer Developer Belfast -This saturday 4th of April

Mon, 30 Mar 2009 13:46:33 +0000

Hi.

As you might know I’m talking at Developer Developer Developer Belfast ( I refuse to call it DDD, in my head that is Domain Driven Design and I want to keep it that way)

There are plenty of really interesting talks ,I’m looking forward to either Creating extendable applications using MEF or DDD, SOA, Messaging, Architecture and jQuery Deep Dive or A peek at Silverlight 3. You can see the complete Agenda here

And you can register to attend the event here. I think there are some places left.

Hope to see you there!

Andrea

Monorail Presentation

Sat, 28 Mar 2009 00:48:02 +0000

Hi there:

I have just uploaded my presentation about castle Monorail, you can find it here.

[slideshare id=1212832&doc=monorailintroduction-090327185816-phpapp01]

The sample code for the presentation will be uploaded soon into some code repository, its a bit too late and I rather go to sleep now. :)

Corrections and feedback are always welcome. :D

By the way, there was a little bit of a reschedule and my talk is at 13:30.

Hope it all goes well tomorrow. Looking forward to it.

Andrea

OssBarcamp tomorrow 28/03/2009 at DIT Kevin Street

Fri, 27 Mar 2009 15:03:48 +0000

Hi there just a friendly reminder about OssBarcamp

Its tomorrow from 9.30am to 4.30pm

there is a map to the location here (really close to Whelans)

It should be great fun. Looking forward to see Jaime’s talk on Git and other talks look really interesting too (jQuery, webdev tricks, etc). I hope some people will show up to my little talk about Monorail. I ll be uploading the content (slides and samples) this evening (i ll add the mandatory post about it here when I do) . Your questions or comments will be appreciated

Cheers

Andrea

Ada Lovelace Day:Barbara Liskov

Tue, 24 Mar 2009 18:21:05 +0000

Hi.

This is my post for Ada Lovelace Day.

Barbara Liskov (born Barbara Jane Huberman in 1939) is the creator of the Liskov Substitution Principle, **this is how I got to know about her work, **also

She was the first woman to get a PhD in computing in the United States (1968) [so close in time to the summer of love … makes you think about the history of the world…anyway]

Only recently Barbara won the prestigious Turing Award, an award known as “the Nobel prize in computing”. It was awarded for her work on the design of programing languages. Her research was very significant because it makes software easier to construct, modify and maintain, these ideas derived from from her experience building the VENUS operating system, a time sharing OS .

If you remember when S.O.L.I.D became a bit of a buzz word last year, then you know that the L is for the Liskov substitution principle, as described by Barbara Liskov:

` Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T. `

then explored by Robert Martin ` Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. ` This is a very important principle that gives you guidelines on how to avoid coupling (if you want to keep reading about it read the Martin article is quite a good read).

Honestly I don’t mind who is the source of knowledge, however there must be something wrong going on in the world since there aren’t all that many women in IT and even less in software development, I dont really know why but I certaintly hope it changes and maybe this little post will help just one little bit to show that women in IT can do wonderful things, as Barbara Liskov they can come up with the one of the most important principles of software development.

Get coding girl!

Some other links:

http://web.mit.edu/newsoffice/2009/turing-liskov-0310.html/

http://www.engineergirl.org/?id=7963

http://en.wikipedia.org/wiki/Liskov_substitution_principle

Blackout Ireland - No to censorship

Thu, 05 Mar 2009 12:07:28 +0000

This post goes againt my idea of restricting the blog to purely technical matters. In this case is well worht it because our freedom on the net is threatened.

What Happened

IRMA (a consortium of record labels) sued Eircom and then Eircom settled the case out of court to (amongst other things I’m not really sure) implement a three strike policy and censor sites, ie if you are with eircom and IRMA tells Eircom somesite.com must be blacklisted, then no eircom customer will be able to see that site (not sure on the specifics of this and how the process to block a site will happen) . This means censorship to me. Censorship should not come from companies I don’t think.

The Three strike policy is as described in the IRMA website

28th January 2009 - P2P Infringement Case Settled**High Court proceedings between four major record companies, EMI, Sony, Universal and Warner and Eircom which have been at trial for eight days, have been settled on an amicable basis with both sides expressing satisfaction with the outcome.    

Both parties have agreed on a joint approach under which they will work closely together to end the abuse of the Internet by P2P copyright infringers.

The settlement reached between the parties provides that the record companies will supply eircom with the IP addresses of all persons who they detect illegally uploading or downloading copyright works on a peer to peer ( P2P) basis.

Eircom has agreed that it will from now on implement a graduated process in which it will:

1)	inform its broadband subscriber that the subscribers IP address has been detected infringing copyright and

2)	warn the subscriber that unless the infringement ceases the subscriber will be disconnected and

3)	in default of compliance by the subscriber with the warning it will disconnect the subscriber.

The record companies have agreed that they will take all necessary steps to put similar agreements in place with all other IPSs in Ireland.

Let me get this straight, I don’t think is wrong that the IRMA wants to protect their copyrights, however this is not the way for many reasons.

For a start How would they know for a fact that the registered person to that ip is the one doing the illegal download? how can they assure they’ll get it right , every time ? How about some guest in your house downloading stuff. What if you download things by mistake? How do you appeal to this process? … the list of questions is endless

Why this is an issue?

On a practical level If you use the internet on a daily basis this is a huge issue because you could get cut off the internet even if you have done absolutely nothing wrong. Most people I know use internet for work. or log in to work from home at least some times. On an ethical level: I really think this kinds of policies should not be implemented at all. And if they have to be implemented they should never be implemented by companies, they have their own interests and they are not those of the general public

I’m hoping to continue a series of posts on this issue. If I have stated something that is incorrect please let me know

Presenting at Developer Developer Developer Belfast

Mon, 02 Mar 2009 12:42:20 +0000

Hi there

I received an email yesterday confirming I will be presenting “An Introduction to Monorail” in Developer Develop Belfast the 4th of April. I’m really excited with this.

I just would like to say Thanks to you. And by you i mean people who are reading this :) because possibly you voted for my session.

Now the hard work begins

If you have any suggestions or comments on either the topic or on presentations please do add a comment.

Thanks again

Andrea

PS I ll add my slides here in the next two weeks

Careful What you Cache For

Mon, 23 Feb 2009 18:07:05 +0000

Had a DetachedCriteria, very simple, I check it running with profiler side by side and I see loads of queries running. Why?

The criteria was something like this ` var criteria = DetachedCriteria.For() .SetCacheable(true) .SetCacheRegion(CacheRegions.RarelyChanges) .SetFetchMode("Things", FetchMode.Eager) .AddOrder(Order.Asc("Name"));`

I was trying to cache a criteria for MyEntity and have an eager fetch mode for Things ( a collection of Thing) , so, it turns out that i have an n+1 .

In the view, there was an iterator in the Things Collection, so just to confirm I removed the reference in the view to this and profiler was running the expected queries(no n+1).

removed the references to caching in the criteria just to see what was happening, an the resulting query was getting what it supposed to get, added the call in my view for each Thing in the Things Collection perfect, the query was running fine and not doing the n+1 .

I decided to leave caching out just this one time and I’m writing this post to remind myself to check exactly why this is happening, or maybe someone will have the answer already?

Can’t remember the definition of MyEntity, might add it to comments later

Technical Speaker Training Event (free)

Sat, 21 Feb 2009 11:00:16 +0000

Hi all:

I’m really glad this is happening, there is going to be a series of meet ups to learn how to do technical talks specially for woman in technology.

The meet ups are going to be about an hour and a half long on how to do technical talks. This is something organized with the girls from Girl Geek Dinner.

The talks are as follows:

Speaker Night 1: Thursday, February 26th from 6pm-7:30pm

Topic: What Am *I* Supposed to Talk About?

o Finding your voice

o Coming up with topics/content/titles

o Building a story from your content

Speaker Night 2: Thursday, March 5th from 6pm-7:30pm

Topic: The Nitty Gritty of Technical Talks

o Demo-ing with code

o Useful tools for technical demos/presentations

o Things everyone hates

o Failure recovery

o Your failsafe list

Speaker Night 3: Thursday, March 12th from 6pm-7:30pm

Topic: Grooving and Improving

o Handling Q&A

o Techniques for self-improvment

o Critiquing your own performance

o Finding your honest feedback crowd

Speaker Night 4: Thursday, March 19th from 6pm-7:30pm

Topic: TBD – we’ll either repeat a session or do a special request like slide-building?

More information [googlemaps http://maps.google.com/maps?f=q&source=s_q&hl=en&geocode=&q=24+south+william+street&sll=53.341713,-6.263859&sspn=0.003734,0.009656&ie=UTF8&t=h&z=14&iwloc=addr&ll=53.348348,-6.258602&output=embed&s=AARTsJpj7OjDNNuzRphacrg3G3maojD-_Q&w=425&h=350]

Tool set for .net development

Sun, 15 Feb 2009 12:40:39 +0000

I have 10 minutes to write this, and I ve been meaning to …

This is a few things that I use (or want to try) :

Unit Testing Tools

MbUnit - Faster to test AR Datamodels

NUnit Nothing bad about it, nothing that made me go wow! that’s great! (that i can remember right now)

and of course

Test Driven Just love the fact that you can right click a test, a unit or a project or a solution and just run the test or in the worse case scenario debug the test.

Mocking Tools

Rhino Mocks Used it a few times, don’t really like it, perhaps because I don’t understand it all that well

Type Mock Supposedly easier to use but compromises design

Roy Osherove posted this today on twitter. Basically a google code projet to compare differnt mocking frameworks, since this is part of the topics for alt.net meetup next month have a look :)

DI IoC Containers

Windsor/MicroKernel

Windsor is an Inversion of Control container, it helps you decouple your code and by proxy, it makes your code more testable. IT is pretty obvious I’m not gonna go into detail, however I will say I found this to be very useful

Structure Map

I havent used this IoC DI tool, is in my wish list and would like to see how it differs from Windsor.

Commons

**Edit:I **had to add this, Rhino Commons this includes two things that are very useful, a generic Repository ( i know some peoplea re against this) , the Log4net helper and the IoC helper

IDE Add Ins

I don’t think i even have to mention ReSharper, I really can not code without it :) KeyMap here

In my wish list and from JetBrains as well, is to test Team City,a simple to use CI; an alternative to this is Cruise Control.net , not so simple to set up but open source

Reflector by Red Gate is a handy tool as well. Use it a lot to inspect castle helpers. Reflector was originally developed by Lutz Roeder ; Red Gate has promised to maintain a free version for the benefit of the community. I Really hope so.

I’m doing web development , this obviously means I’m using Firebug. I found gotapi.com a really useful site (html, css and js reference amongst others)

Browsers: my default is Chrome at the moment, however I use Firefox and ie ( to test that it works )

No more time for today will continue later .

Have a Nice Sunday! If you feel like it, what is your tool set?

I do not blog about WINE...wait actually I Do!

Tue, 10 Feb 2009 11:44:30 +0000

I saw some incoming links from curiouswines.ie and I though I would clarify I’m not a wine connoisseur (I ll keep trying tho :D) however, the word does remind me about WINE, the translation layer that allows windows applications to be run on Linux.

Please note WINE stands for Wine Is Not an Emulator, hence not paying the penalties of one. It looks like this is mostly for games, thou Photoshop and Autocad are supported (with minor issues) I dont really need either right now but you never know when you are going to need one.

For the more conventional wine (ie the one to drink), i think you better to talk to the guys down in Cork, curiouswines.ie .

Iron Ruby and talking too fast

Mon, 09 Feb 2009 15:03:54 +0000

So today i was reading an article by Ben Hall on Getting Started With IronRuby And RSpec, Part 1 after I read a few paragraphs I twitted that there were “..so many things in this article that I disagreed with” Ben listened and … asked me why.

I actually disagreed about some sentences that talk about the processes, or opinions about stuff (for example naming conventions and whent you need a framework ) however the article is really good, it explains very clearly what is the purpose of the post, there is a nice intro into Iron Ruby, some sample code, then rspec and the difference between BDD and TDD as well as a very extensive warning about how mature Iron Ruby is

What I ve learned

Read the whole damn article before saying stuff
Give reasons why is good/bad
Maybe read less things, but read them properly
maybe testing with IronRuby is viable and would be really nice to give a try
I actaully miss duck typing much more that what i remember
something that I’m obviously forgetting, that i though I should add and forgot

Anyway

Cheers

Pragmatic Ubuntu?

Fri, 30 Jan 2009 10:17:18 +0000

Through Andy Hunt’s Blog ( one of the Authors of The Pragmatic Programer) I got the Pocket Ubuntu guide for free.

Thanks Andy and thanks to Keir Thomas for making this available in the http://www.ubuntupocketguide.com

I just went through the first chapter and found out about Wubi ( possibly something I will try now as I like the idea of trying things quickly without having to reboot, installing… no i didnt read much yet).

Edit installed Wubi and its not a virtual machine of some sort as I originally though, however its a really easy installer for windows, I intalled it as a program then rebooted and there it was, dual booting without the headaches :D with a full ubuntu desktop, not what I thoough it was but real nice :)

So far the book looks good, more on it later on.

Cheers :D

Two New tools

Thu, 29 Jan 2009 17:43:59 +0000

In web development, you come across tools all the time, some are incredible and I was lucky enough to find two today.

Firescope is a firebug plugin that gives you HTML and css help. its really neat

it looks like this in your firebug

(note to my friend: note the lower case logo!! hehehe)

Another tool that is kinda cool , but I would probably not use that much but the days that i need it I will http://www.scrnshots.com/ they have some tools and a nice api, that you can query and mash it up where ever you feel like. This is what i mean

I hope it helps :)

Find the problem, then the solution

Tue, 27 Jan 2009 12:19:43 +0000

I found myself making the mistake I read about a lot of times.

It turns out we have to migrate parts of an existing solution to a different platform and I had all this questions about how to organize the new solution and I realised, hold on, I must first have a deep dive into the existing code and then start thinking about the new solution and how to architect it.

I was so easily driven to think about the solution that I lost sight of the problem, terrible and now I’m advertising it…

Maybe it was just the idea of going through the existing code disgusted me so much that I didn’t want to think about it? or maybe its the fact that reading code is harder that writing it?

Hopefully I learned from it.

Dublin Alt Net Meetup - 12th of Feb 7pm

Mon, 26 Jan 2009 10:27:00 +0000

Hi there:

As a new chapter of this post finally we are doing an Alt.net meet up, I can t wait and hope for the best. The meet up will be the 12Th of February at 7pm in The Duke (off Grafton Street). Unfortunately we didn’t realise it was on the same day that twestival ( a charity event for twitterers) I think we are very different events, thou I’m sorry I ll be missing it, as it is a worthy cause.

I like the definition of Alt.net I found in David Laribee’s blog

What does it mean to be ALT.NET? In short it signifies:

You’re the type of developer who uses what works while keeping an eye out for a better way.

You reach outside the mainstream to adopt the best of any community: Open Source, Agile, Java, Ruby, etc.

You’re not content with the status quo. Things can always be better expressed, more elegant and simple, more mutable, higher quality, etc.

You know tools are great, but they only take you so far. It’s the principles and knowledge that really matter. The best tools are those that embed the knowledge and encourage the principles (e.g. Resharper.)

I think we might be comming late into the party, however I’m not interested on how are we called, I see it mostly as a way to learn and exchange ideas, solutions. Hope we can get talking about interesting topics and that we can come up with a plan for the next meet up.

Anyway, hope to see you there :), if you have any suggestions or comments you are very welcome

A Talk about Castle on the way

Tue, 20 Jan 2009 01:57:58 +0000

Hi This should be pretty exciting, I’m hoping to do a talk in OSSBarcamp ( well not really a talk but you know) and depending on votes, I might be talking in DDD Ireland too, we will see.

The talk will be on Castle Project, a walk through of a sample application, the main focus on Monorail and Active Record as I saw some other people can cover IoC and DI ( which in itself is a really long talk).

I have still to decide what this app will do, I actually wanted to build something simple but useful, a few ideas but nothing that I go, yeah thats right, suggestions welcome)

I asked some people for advice on this “create a talk” thing. I think the most sensible answer I got so far is to tell the advantages of using castle first.

Alt.net Ireland

Mon, 19 Jan 2009 10:26:17 +0000

We met with some folks in the open coffee recently. It was really nice to have a good turn out and a lot of new faces. I had in mind to talk about Alt.Net and I think one thing that is clear now is that we need to come up with a clear to do, how are we gonna work? where? that kind of thing. Its also important to have an easy way to explain this easily.

I think it’s about learning from your peers, having a space where , if you have a problem you can bounce ideas or ask if your solution is good. Someone is bound to have gone through a similar situation.

There were some discussions, and my view on this is, we should focus on the best solutions, and what are the best processes to get there and why.

Open Coffee was great, I was really sorry I had to leave so early… looking forward to the next one. :)

Ruby Jobs live!

Fri, 09 Jan 2009 16:27:09 +0000

Hi all just though I’ d advertise the fact that rubyjobs.ie is live.

I’m really happy with this, Its great to see the community releasing things. Ok its very basic but I think is a really good start. Most of the effort came from Gavin Joyce, but Declan and other people (that I cant remmeber right now, sorry no memory ) contributed to the project; it is open source and hosted in github.

It all started last meetup and It will sure continue on the next one , that is the 13th of January @ 7pm in 10 Upper Fitzwilliams Street.

[googlemaps http://maps.google.com/maps?f=q&hl=en&geocode=&q=+10+Upper+Fitzwilliam+Street&sll=53.344104,-6.267494&sspn=0.263178,0.53009&g=10+Upper+Fitzwilliam+Street&ie=UTF8&t=h&z=14&iwloc=addr&ll=53.342866,-6.245556&output=embed&s=AARTsJoTF_5PsIIoZOTSk5Bpqn90_tEkZA&w=425&h=350]

Thanks again to IGO People that kindly provides the meeting room :) and they also launched very recently.

Component View Caching with Castle

Wed, 07 Jan 2009 12:41:44 +0000

I had to add some caching for a ViewCompoment in castle recently and, at least for me, it wasnt too clear what to do at first.

A ViewComponent is a very handy thing in castle, amongst other things it allows you to have aView Component that can be, a login box, a menu, an rss feed reader. Sometimes the you need to cache the viewcomponent and this is how you need to go to this post by hammet

I couldn’t use the decoration ` [ViewComponentDetails(“comp1”, Cache=ViewComponentCache.Always)] ` because I needed the component to be refreshed every so often , so I used my own implementation ` [ViewComponentDetails(“BlogComponent”, Cache = ViewComponentCache.UseCustomCacheKeyGenerator, CacheKeyFactory = typeof(YourCacheKeyGenerator))] `

_YourCacheKeyGenerator _is a class that you create that must implement _IViewComponentCacheKeyGenerator _something similar to ` public class YourCacheKeyGenerator: IViewComponentCacheKeyGenerator { public CacheKey Create(string viewComponentName, IDictionary parameters, IEngineContext context) { CacheKey key = new NamedCacheKey(); ….. ….. your implementation here return key; } ` I made my implementation dependant on time but you can make it dependant on anything you need

If there are any errors or comments please let me know

How to use Google webmaster tools with wordpress

Wed, 31 Dec 2008 11:27:00 +0000

I found this post on how to verify google webmaster tools.

Basically you just create a new page with the name of the html that google requires, if you choose the option to upload a new page.

Cheers

Happy Holidays post and welcome 2009

Tue, 30 Dec 2008 13:20:05 +0000

well this is one of those end of year post that I think you must write. This is the first year I actually keep my blogging pretty constant (thou changed blogging engines …) so first time I’m actually writing one of these. Anyway

I’m very happy with the year thats g0ne, **loads **of changes in my life, one of them being having no weekends at all for most of the year as I ve been working on a project with a friend of mine. That project is going well, we can nearly touch the code complete stage , only 8 tickets left open now so that’s great, I ll blog more about it when I know how public we want this to be. And yes it is written in .net with the castle project (castleproject.org)

I ve been paying more attention to networking and its paid off big time, so next year I’m gonna do more of that, and hopefully i ll dare to prepare a few talks on castle, as I ve been using Monorail, ActiveRecord and Windsor. However If I have to prepare a talk I will have to do some serious reading that I ve been meaning to do to actually have a more complete knowledge.

In 2009 I want to get my teeth into RoR I ve been trying to put time towards Ruby Jobs ( please refer to previous post too lazy to actually fetch the link) however due to the project mentioned above its impossible, it just eats all my time.

Another great thing that might not interest anyone but me is that my brother is coming over to visit me for a few weeks, he is 19 and reading Computing, I’m sooo proud of him.

Looking forward to FOWA Dublin , OSS barcamp, DDD .

Looking forward to a lot of really cool new records that hopefully will come out.

I think 2009 will be a very challenging year, I hope not too see too many friends go ( I miss a few that left Dublin already) and I hope this will not turn Dublin in a less secure place, I think we all enjoy been able to walk to and from places.

Another thing that I want to see happening and I want to contribute heavily towards is, dublinalt.net I hope it works out and that we all learn a lot.

Mostly I would like that people are happy and that we enjoy the journey as we go.

Happy 2009

Andrea

Languages

Fri, 12 Dec 2008 14:59:06 +0000

I was reading hanselman’s blog today about languages, not programing languages, but spoken languages like english, spanish, french, chinese, etc.

The post kinda discusses , “if you dont speak englsih , you are not a programmer”,

I think the post is worth the read and I have two comments about it.

As native spanish speaker I have to say the fact that I was interested in French from a early age and english later on helped massively when I started programming because I could make sense of things faster. Later on, at college , even thou we had english as a requirement in college, most people couldn’t actually read papers properly and they would prefer even badly translated copies

Another thing I have to add is that, a friend of mine, Cristian Espeche, is a great developer, however he still finds it really hard to get documentation and I know he knows he would be a much better programmer if he could read english, I’m mentioning this in my blog to maybe encourage him to learn :) .

I dont know what the solution is yet but I can see this is a problem

Ruby Ireland Meet up

Wed, 10 Dec 2008 16:57:04 +0000

Yesterday we had a really nice Ruby Ireland meet up some links

Rest link
RateMyArea talk http://ciaran-lee.com/RMA-rug.pdf
google Geo Location API via Darragh link

Follow up on the website and other projects soon

The idea is that the next meet up (would that be teh 13th of January) is a meetup that involves coding.

Thnaks to the people providing the sambos, beers and mince pies and above all the place to have the meeting.

Moving

Mon, 08 Dec 2008 17:50:57 +0000

Hi there. This is my firt post in wordpress, I ll be migrating all previous posts from http://ohmygodiamacat.blogspot.com/ So many questions so little time ….

Linking images in Monorail

Sun, 30 Nov 2008 17:56:00 +0000

A quick one

Say you have an image or god knows what and you need to add a link to it, in html you’ll do something like:

In a view you can do this:

1
2
3
4
    
<a href=$UrlHelper.For("%{ controller='product'}")>  
    <img src="$!Image.Path" alt="$!Name" />
</a>

Ruby Ireland Meetup - 9th of December 7.30 Fitzwilliams Place

Wed, 26 Nov 2008 15:01:00 +0000

It looks like Ruby Ireland is getting a bit more attention from people, and that is great to see I had my own reservations about if I should continue going to these meet ups because basically I haven’t been doing much Ruby in the last months, but I do love to hear about it and it does give me ideas about how to work on my own code. I see people solving problems in a completely different way to what I would do and I think that has value and I hope they don’t mind me showing up there. Also ,there is a common ground in software development and web development in particular. This is why we are gonna start a podcast on software development and I hope it will work out and by work out I mean that it makes us learn more about how we develop software and hopefully get some feedback from the community, no matter were they are.

Declan McGrath came up with the idea in a thread in ruby groups, we met up and came up with some ideas for topics:

Ruby

in general about hosting an Ruby on rails application,
how do mongrels work and what do they actually do,

** General Software development Topics **

What is Inversion of Control Dependency Injection and why do you use it
Improving your tests . Test Driven Development

** Tools / frameworks**

What Tools are you using for software development productivity
The Linux distro Declan is using for recording/editing the sessions
Funnily enough I would probably mention castle

After, we got some interest from Justin McCarthy (haven’t met him yet) but its great to see more involvement. These are initial thoughts would welcome any suggestions , corrections later on, etc

What s happening

Wed, 26 Nov 2008 13:06:00 +0000

Since my last post I ve been trying to avoid writting about trivial small things however meaty post take time and I just dont have it right now.

Questions in my head now

when do you create a service?
where can I find an example of a well designed GWT app?

Events that Im interested in

GGD 4th of December in La Taverna di Baco in the Quays (in dublin)

IJTC its the 7th of January in UGC, some good speakers but it feels like thi IcTC conferences are a bit desorganized

FOWA Dublin - March 6th. I want to go but dont know really why

Edit: missign OSSBarcamp Dublin - 28th March 2009 this is one I want to go to as well :)

Cool Things

- I ve been using Pencil ( a pluggin for firefox) and its pretty cool because its easy to use, lightweight, free. Great for putting screens togheter quickly

Ruby Ireland Meetup

Wed, 10 Sep 2008 12:25:00 +0000

I was in ruby Ireland last night ( good turn up btw) and it was great to see Paul Campbell talking about Couch Db, a non relational DB in their own words

“Apache CouchDB is a distributed, fault-tolerant and schema-free
document-oriented database accessible via a RESTful HTTP/JSON API. Among other
features, it provides robust, incremental replication with bi-directional
conflict detection and resolution, and is queryable and indexable using a
table-oriented view engine with JavaScript acting as the default view definition
language.”

Anna showed some interesting rake tasks and i did a short intro to jQuery (slides here) hopefully someone found it interesting.

This Saturday the 13Th is the open coffee meeting in the New York Grind that will include the talk about trying to come up with something similar to alt.net Ireland. as discussed in previous post

And the universe didnt disapear (aparently) thumbs up.

jQuery ExtJS talk

Wed, 03 Sep 2008 10:48:00 +0000

I’m doing a lighting talk about jQuery and ExtJs (maybe mention GWT) in the next Ruby Ireland on the 9th of September link

I ll add a link to the slides as soon as i finish them, any suggestions very welcome. so far I’m doing a quick intro, some of the features, stuff i found useful or interesting or use with code samples and finally some links. For jQuery I’m touching on ui.jquery and themeroller and the event observer implementation link

For ext again intro and show some code and then maybe touch on EXT (GWT implementation of EXT Js) just started to have a look at this but it does seem very promising

Cheers

From Code Monkey to Code Crafter II

Wed, 03 Sep 2008 10:34:00 +0000

Hi again

Well hopefully that meeting will go ahead on the saturday the 13th of september

http://www.opencoffeedublin.com/september-saturday-opencoffee-dublin-1392008/

looking forward to it now :)

Trying GXT (ExtJs in GWT)

Fri, 29 Aug 2008 10:13:00 +0000

Today I’m trying out Ext GWT

To use Ext GWT

Installation was simple ( i needed the java sdk i got 1.6Update 7 )

downloaded GWT1.5.1 and decompressed it. happy days!

then i ran the sample hello and I was running, really fast

[if you have problems with some error that ends with and then an exception, it s very likely to be that your path is reading some other version of java first, if so go to environment variables and change your system settings so you have the recently installed java sdk first]

to check the java version open the command line and do java -version

Why Ext GWT?

GWT is a compiler that converts Java source into JavaScript

this means you write and test java code

Getting Started

as in the sample i went and changed the email application and it changed properly and that was cool, lets get to the business now

lets create our own app and try to handle some event

Creating an Application

There is an ApplicationCreator that generates a series of files including a java file with a sort of hello world, an html file a css file and two cmd files this all following a naming convention.

Adding support for GWT -EXT

OK I went to the Ext GWT documentation web and there are a few screencast, if you follow them you get to the EXT-GWT (from extjs.com) hello world however there isnt much more sample applications , there is one but seems like a big jump

To be honest this took a while to get right, I’m not used to java and the path convention is a bit too strange, i followed the video in the docs above and finally its working :)

From Code Monkey to Code Crafter ftw

Wed, 27 Aug 2008 15:13:00 +0000

This idea has been in my head for a while now, I’m sure all developers get here at some point where you want to move forward but not terribly sure how to get there, how to get better, how to write elegant maintainable code that you are proud of.
For me it all started when I saw how ruby on rails worked and now I’m on the path (i think ) to become better and coding using principles like mvc, active record, etc
I remember I started assisting Ruby Ireland meetups and there was nothing like that for .net or java and it still feels like there still isn’t a place(maybe i didnt look properly please let me know) or group that you can say, hey lets do

A code jam about data models or
A talk about how to do high performance Persistantent Domain Models or
A talk about a particular project the talker worked on and what they learned in a very detailed technical way [not interested in company secrets but how to become a better dev how to learn from other peoples experience ] or- hey lets compare javascript frameworks or
This is how you do unit testing in lolcats(im making this up but i recon this exists).

I would like to think this is possible, I would like to think that the group can be technology agnostic to a certain degree as i believe most best practises are general for all languages, however I am a c# developer so I talked to Martha Rotter about this and she was interested so we met and talked about this and we will be meeting in open coffee with other (hopefully) like minded people I will post here a date when this is decided but please let me know any thoughts and comments

Baiscally I’m interested in relevant, higher level developer talk, in concept very similar to alt.net groups around the world. http://altnetpodcast.com/ http://altdotnet.org/ following good design principles from the Patterns book from Martin Fowler, apply XP , etc

Cheers

EDIT: Ozone thanks for agreing to the use of code crafter :D

Note: Thanks jaime for the proof reading :D

SSIS Pain

Mon, 18 Aug 2008 22:11:00 +0000

hi
This post is basically a rant, a rant about SSIS, whoever designed this UI please take a good look at your career and either retire or consider a career change.

I think the idea behind this service is great; we all need data migration tools; but why make people suffer?
Some examples of why this tool drives me insane; in a data flow, you can createa Derived column, say for some crazy and ridiculous reason (please ntoe sarcasm here) you need to change your something on your source, well then the aforementioned Derived Column thing gies u a nice error(to a level fair enough), but then you deal with the problem you click ok, the dialog closes and then you have to open the same dialog again, why?

Anyone that say that they think SSIS is great is just because they haven’t used it.
Rant over ( however i need to keep going with this data migration)

Time picker / PNG Transparency fix

Tue, 05 Aug 2008 08:40:00 +0000

Hi. at some point we all need a click time picker, found this one (in ajaxian)

Also in Ajaxian, I found a PNG fix I used the sample and it works, however I can’t make it work on my server, it doesnt even hit the *.htc file.
The instructions say that you should give the path to the htc relative to index.html however I dont seem to be able to get it up and running for my web app, anyway… will try again with a little bit more time later on.

NVelocity Parse

Wed, 23 Jul 2008 20:12:00 +0000

A little thing that drove me completely insane

when using parse (appache ref) the path to the view includes the folder that you are in

say you are in the folder …/views/Blog
editing a view called one.vm
if you want to parse something in the same folder as one.vm you have to use

#parse(“Blog/two.vm”)
and if you happen to use a / before blog you ll get a nice exception that has a very unclear message

Just to note

NVelocity - creating urls

Wed, 23 Jul 2008 19:58:00 +0000

I always forget these two:

$Url.Link('label', "%{controller='controllerName',action='actionName'}")

and this:

To Create a form

$Form.FormTag("%{id= 'formId', action='save', immediate = 'true'}")  
$Form.EndFormTag  

I really wished there was a MR RC4 :D

Transparency Fix for PNG on IE

Wed, 23 Jul 2008 19:44:00 +0000

Saw this on ajaxian and i think is really handy and at some (not too far in time i ll need this)
http://www.twinhelix.com/css/iepngfix/demo/ basically to add some transparency you just add a few files to your sever and a line of css and thats it.
Will tell when the time to use this comes :)

Small but interesting find

Mon, 07 Jul 2008 16:03:00 +0000

Yesterday I was coding and I needed to create a criteria like

Repository.FinOne(Restriccions.Eq("Email", email));

however I wanted to make sure that there was not problems with casing. It turns out IgnoreCase exists and can be used this way :D

Repository.FinOne(Restriccions.Eq("Email", email).**IgnoreCase**());

I was really happy to find this, thanks NHibernate in Action!

Speed is all

Fri, 04 Jul 2008 08:06:00 +0000

PDF Readers

I’m thinking about a serious of “meaty” post for this weekend or at least the one decent one, but meanwhile I though I should post about the incredible difference in speed between Adobe Reader and Foxit. A friend of mine (one of the two subscribers to this blog) told me about foxit like a year ago, I went yeah yeah but then about two weeks ago I actually download it and it is really fast, I love it.

FF2 vs FF3
OMG I’m so happy with FF3 I’m still testing it in only one of my machines but so far much better performance and now that firebug is behaving, happy days. The Add ons I have are: Firebug with YSlow, Jiffy, Web Developer, and of course Google Toolbar. The best feature is no memory problems :D

Now tempted to install the Beta 2 of IE8….

Jiffy

Tue, 24 Jun 2008 16:44:00 +0000

This is a firebug extension for measuring accurately the JS performance I have installed and tested it in this site sounds like a good idea and to see it running makes sense will start using it from now on,particularly on extJs sites ;p

Nokia Open sources Symbian

Tue, 24 Jun 2008 11:36:00 +0000

Talking about open sourcing http://www.nokia.com/A4136001?newsid=1230415

Sign the Entity Framework Comunity Vote of no Confidence

Tue, 24 Jun 2008 00:40:00 +0000

OMG I just saw this http://efvote.wufoo.com/forms/ado-net-entity-framework-vote-of-no-confidence/ and I had to post it.

IOTC Conference

Mon, 23 Jun 2008 10:44:00 +0000

Last Thursday and Friday I was at the IOTC, an Open Source Conference. I went to a few talks

1) Saw Geoffrey Grosenbach talking about Phusion Passenger. The talk target was a bit too wide, however I think he was good at explaining some of the basics. It would have been good to see some sample code but hey. All in all interesting

2) Talk by Clint Oram the guy from Sugar CRM, well he was basically evangelising about Open Source in general, TBH It was really boring, maybe I just didn’t understand the whole topic of the talk … I believe most of us in the audience were developers, I wish he showed us some goodness, some features, some smart API …or how do they manage their interactions with all the developers in !=locations, how do they evaluate whats code to include or not, who is in charge of that, etc …
He mentioned some deal that they(Sugar CRM) made with hosting 365 and Clint is now living in Ireland.

3) WURFL and WALL. This talk was the start of a really interesting day and a great talk about something I might be using at some point . WURFL is a Device Description repository, it uses a tag that the device send to find out what capabilities does the device have, WURLF seems to fit in nicely with WALL, a markup language (that reminded me a little to nVelocity) that renders according to the querying device. Really interesting and real cool the way the WURFL file is organized (and a surprising 8Mb File)

4) ZOPE. A Phyton Framework. I think this talked turned out to be very different to what was originally intended however it was good to hear practises applied to a OS Irish Shop. There was a lot of talk about how their complete process flows, from development to deployment. For example he mentioned how they use subversion, firebug, how do they use versioning of their phyton and db versions… and then he talked about Zope, I only had a very diluted idea of what was Zope Architecture and what was it supposed to do, I’m still not terribly clear however there were some interesting details all the food related stuff was real nice(and good easy to remember names) Eggs, cheeseShop, etc. I must check the entity generation as it sounds very interesting.

The presenter, Con Hennessy works for a company called OpenApp interestingly they deploy solutions for the government, he mentioned the HSE. All in all real interesting

5) PHP Frameworks. This talk really took me by surprise, David Coallier is part of the php core team and he knew what he was on about. He talked about web frameworks: Cake, Zend, Symfony (all MVCs) and Prado( an event driven one that I don’t find interesting at all) then he went on talking about testing frameworks (this was really interesting as I knew nothing about php testing frameworks) here the list was PHPUnit, SimpleTest (it looks like he liked this one and I liked the asserts syntax) and another one that was for real low level testing (hence not interested as I know for sure I’m not gonna be debugging php core anytime soon )

That’s all for today I wanted to add some nice pics but as I was searching I realised I don’t know how to make sure I’m not breaking any law by using images so I’ll find out later and go to sleep now

Super easy image replacement with jQuery

Wed, 18 Jun 2008 17:52:00 +0000

http://www.webdesignerwall.com/demo/jquery/img-replacement.html
look at the source code for this, is it clean or what?
took me little time to get something up and running in a real nice way
This is a sufficient reason to love jQuery and whoever it is wrote this :)

Cheers

Js Frameworks usage amongst top sites

Fri, 13 Jun 2008 16:04:00 +0000

http://royal.pingdom.com/?p=305

First Prototype, closely followed by jQuery :D then moo

Theme Roller and UI.jQuery

Wed, 11 Jun 2008 18:20:00 +0000

I really like this UI.jQuery.com
Will post more later…

Silverlight 2 Beta 2 Installation

Tue, 10 Jun 2008 21:57:00 +0000

I saw Scott Gu’s post about Silverlight and I decided OK I’ll try it. Well, the install took 10 minutes and I had to close everything (Visual Studio ,IE Firefox), such an nuisance compared to the instal of Yahoo’s Browser plus. Did not try anything after that, to be honest , it doesn’t call me or something… I’ll need to be pushed into this one.

New release of Nhibernate EAP

Tue, 10 Jun 2008 21:44:00 +0000

The most interesting thing today was an email from Manning with the new release of the EAP of Nhibernate in Action (still in chapter 3 :( ) .
On the plus side, first time I ever bother reading the table of contents in detail, and yes, I found an appendix called Introducing ActiveRecord and MonoRail, at first this made me really happy, but now that I think about it, the appendix should really only be about Active Record, else its gonna be too short.
I think I would like to see a mention of Machine Migrations (and similar tools)

PS: Did I just say this is the most interesting thing in the day ? ( well apart from lunch in the park yeah, it pretty much was)

No Non-sense jQuery

Mon, 09 Jun 2008 19:28:00 +0000

John Resig just posted some talks he gave and they are so easy to understand that it hurts. I really like the jQuery syntax, ok is a different approach to a JS library than ExtJs, and I like it, unobtrusive and lightweight with loads of plug ins available.

I really like this grid (ok ok it does use a table for layout but hey, looks good and you read the code and immediately know what’s happening) .

MS Word save to PDF

Fri, 06 Jun 2008 11:39:00 +0000

hi there
I don’t think this is ultra necessary or anything like that but I know I’ll need it at some point, Microsoft has a plug in to save a document as a pdf its well integrated and seems to work ok.
here is the url http://url.ie/f9v
there are other options if you don’t have word 2k7 I think is called pdf95

Another Debugger for IE

Thu, 05 Jun 2008 19:21:00 +0000

We all know how painful it is to debug websites in ie, (particularly 6 what a terrible browser that…. i ll rant properly about it another day) today i stumbled across this little tool call DebugBar it was all great until I installed it in my machine and it doesn’t work. (no contextual menus, no nothing)
However I ll have to give it a try in another machine as mine is a Vista Home Edition ( yuck yuck) I should be updating to ultimate pretty soon ( hopefully Saturday) when I know I’m safeguarded by at least a virtual environment to work in.

All for now if anyone has comments/ opinions very welcome :D

Hidden Doc Gem - ExtJS

Thu, 05 Jun 2008 12:44:00 +0000

hi again

OK i just found this out last Monday and it was there all along i just never paid attention to it and found it extremely handy.
This http://extjs.com/learn/Ext_Manual there is a lot of JS introduction and also good to read about the component model http://extjs.com/learn/Ext_2_Overview#Component_Model
I just though i d blog about it cause It was easy to miss

Umbrella

Thu, 05 Jun 2008 12:22:00 +0000

Today Ayende blogged about this and i found it really interesting
here: http://www.codeplex.com/umbrella# you can get the code and tests

http://ayende.com/Blog/archive/2008/06/04/Review-Umbrella-project.aspx ayendes blog

Some Cool Things

Thu, 05 Jun 2008 06:57:00 +0000

Today’s interesting find is Browser Plus I heard about this first a few months ago but there was not much real info about it.
I have to say i was really impressed by the installer short, sweet and very intuitive.
Also the capabilities that it provides seem simple but powerful, I’m very interested in the Ruby Interpreter Service
Promising.

Nhibernate from the begining

Thu, 22 May 2008 10:48:00 +0000

I’ve been using NHibernate for a while now, but I never started a project from the beginning or used purely NHibernate (I mean without Castle Active Record).I started to read NHibernate in Action ( the EAP edition) so lets see how it goes¹.

NHibernate in Action Pierre Henri Kuaté, Tobin Harris, Christian Bauer, and Gavin King January 2009 https://www.manning.com/books/nhibernate-in-action ↩

roundcrisis

Bytesize Architecture Sessions for DDD Discovery

The Discovery Step

Bytesize Architecture Sessions Overview

C4 Overview

Bytesize Architecture Sessions for Discovery: A Practical Walkthrough for Smaller Groups

Discovery Kick Off

Next Sessions

Logistics and Tooling

Bytesize Architecture Sessions: A Practical Walkthrough for Bigger Systems

Before the Sessions

Discovery Kick Off

Next Sessions

Outcomes

Common Anti‑Patterns

Success Metrics

Conclusion

The Making of a Decision - Part 5 - Introducing Decision KP Maps

What is Decision KP Map?

Who is this tool for

A sample Decision KP Map

How does it work? A simple example

Strengths

Limitations

How to start mapping? Paper or Online

Other uses

More to do

Conclusion

The Making of a Decision - Part 4 - Team and Personal Tools

Within a team

Bytesize Architecture Sessions

Overview

Why use this tool, in the context of better decision making

Decision Records

Overview

Why use this tool, in the context of better decision making

Personal

Left Hand Column

Why use this tool, in the context of better decision making

Influence Mapping

Overview

Why use this tool, in the context of better decision making

Decision KP Map

Why use this tool, in the context of better decision making

Conclusion

The Making of a Decision - Part 3 - Tools for groups

Across teams

The Architecture Advice Process

Overview

Why use this tool? In the context of better decision making

Team Topologies

Overview

Why use this tool, in the context of better decision making

EventStorming

Overview

Why use this tool, in the context of better decision making

More to come…

LAST Conference Melbourne - November 2025

The Making of a Decision - Part 2- Knowledge

Understanding Knowledge: The DIKW Model

Applying DIKW: A Practical Example

Knowledge Workers

A Systems Lens

Innovation

Historic Lens: Continuity of the “Theory”

The Hidden Barrier: Who Gets to Know?

Conclusion

Resources and Extra Reading Materials

Core Concepts

Knowledge and Power

Decision Making

Related Research

The Making of a Decision - Part 1 - Intro & Power

Sources of Power

Laws of Power

Interesting learning resources - August 2025

Scaling Teams with Ownership: A ProTime case study

Operational and Denotational Strategies by Noel Welsh

All posts by John Cutler

Architecting the uncertain - Getting started with Agile Software Architecture Iteration Zero, C4, Event Storming by Johannes Seitz