Datasets:

markhneedham

/

blog

like 0

2013-10-14 07:27:10

Java: Incrementally read/stream a CSV file

I've been doing some work which involves reading in CSV files, for which I've been using http://opencsv.sourceforge.net/[OpenCSV], and my initial approach was to read through the file line by line, parse the contents and save it into a list of maps. This works when the contents of the file fit into memory but is problematic for larger files where I needed to stream the file and process each line individually rather than all of them after the file was loaded. I initially wrote a variation on totallylazy's +++<cite>+++https://code.google.com/p/totallylazy/source/browse/src/com/googlecode/totallylazy/Strings.java?spec=svna4a6ac3d443db02821d434a5d6560cb77ec4ef4a&r=a4a6ac3d443db02821d434a5d6560cb77ec4ef4a#55[Strings#lines]+++</cite>+++ to do this and while I was able to stream the file I made a mistake somewhere which meant the number of maps on the heap was always increasing. After spending a few hours trying to fix this https://twitter.com/mesirii[Michael] suggested that it'd be easier to use an iterator instead and I ended up with the following code: [source,java] ---- public class ParseCSVFile { public static void main(String[] args) throws IOException { final CSVReader csvReader = new CSVReader( new BufferedReader( new FileReader( "/path/to/file.csv" ) ), '\t' ); final String[] fields = csvReader.readNext(); Iterator<Map<String, Object>>() lazilyLoadedFile = return new Iterator<Map<String, Object>>() { String[] data = csvReader.readNext(); @Override public boolean hasNext() { return data != null; } @Override public Map<String, Object> next() { final Map<String, Object> properties = new HashMap<String, Object>(); for ( int i = 0; i < data.length; i++ ) { properties.put(fields[i], data[i]); } try { data = csvReader.readNext(); } catch ( IOException e ) { data = null; } return properties; } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } ---- Although this code works it's not the most readable function I've ever written so any suggestions on how to do this in a cleaner way are welcome.

java-incrementally-readstream-a-csv-file

https://markhneedham.com/blog/2013/10/14/java-incrementally-readstream-a-csv-file

2013-10-22 20:20:30

Neo4j 2.0: Labels, indexes and the like

Last week I did a couple of talks about modelling with Neo4j meet ups in http://www.meetup.com/graphdb-netherlands/events/137335992/[Amsterdam] and http://www.meetup.com/graphdb-belgium/events/137336622/[Antwerp] and there were a few questions about how indexing works with http://www.terminalstate.net/2013/05/labels-and-schema-indexes-in-neo4j.html?m=1[labels that are being introduced in Neo4j 2.0] As well as defining properties on nodes we can also assign them a label which can be used to categorise different groups of nodes. For example in the football graph we might choose to tag player nodes with the label 'Player': [source,cypher] ---- CREATE (randomPlayer:Player {name: "Random Player"}) ---- If we then wanted to find that player we could use the following query: [source,cypher] ---- MATCH (p:Player) WHERE p.name = "Random Player" RETURN p ---- A common assumption amongst the attendees was that labelled nodes are automatically indexed but this isn't actually the case which we can see by profiling the above query: [source,cypher] ---- $ PROFILE MATCH (p:Player) WHERE p.name = "Random Player" RETURN p; ==> +-----------------------------------+ ==> | p | ==> +-----------------------------------+ ==> | Node[31382]{name:"Random Player"} | ==> +-----------------------------------+ ==> 1 row ==> ==> Filter(pred="(Product(p,name(0),true) == Literal(Random Player) AND hasLabel(p:Player(8)))", _rows=1, _db_hits=524) ==> NodeByLabel(label="Player", identifier="p", _rows=524, _db_hits=0) ---- Instead what we have is a 'label scan' whereby we search across the nodes labelled as 'Player' check whether they have a property 'name' which matches 'Random Player' and then return them if they do. This is different than doing a 'full node scan', checking for the appropriate label and then property. e.g. [source,cypher] ---- $ PROFILE MATCH p WHERE "Player" IN LABELS(p) AND p.name = "Random Player" RETURN p; ==> +-----------------------------------+ ==> | p | ==> +-----------------------------------+ ==> | Node[31382]{name:"Random Player"} | ==> +-----------------------------------+ ==> 1 row ==> ==> Filter(pred="(any(-_-INNER-_- in LabelsFunction(p) where Literal(Player) == -_-INNER-_-) AND Product(p,name(0),true) == Literal(Random Player))", _rows=1, _db_hits=524) ==> AllNodes(identifier="p", _rows=11443, _db_hits=11443) ---- If we want to index a specific property of 'Player' nodes then need to http://docs.neo4j.org/chunked/milestone/query-schema-index.html[explicitly index that property for that label]: [source,cypher] ---- $ CREATE INDEX ON :Player(name); ==> +-------------------+ ==> | No data returned. | ==> +-------------------+ ==> Indexes added: 1 ==> 0 ms ---- If we want to see the indexes defined on our database we can run the following command in webadmin: [source,bash] ---- $ schema ==> Indexes ==> ON :Player(name) ONLINE ==> ==> No constraints ---- or its equivalent in http://blog.neo4j.org/2013/10/neo4j-200-m06-introducing-neo4js-browser.html[Neo4j browser]: image::{{<siteurl>}}/uploads/2013/10/2013-10-22_21-14-32.png[2013 10 22 21 14 32,600] Now if we repeat our initial query we can see that it's a straight schema/index lookup: [source,cypher] ---- $ PROFILE MATCH (p:Player) WHERE p.name = "Random Player" RETURN p; ==> +-----------------------------------+ ==> | p | ==> +-----------------------------------+ ==> | Node[31382]{name:"Random Player"} | ==> +-----------------------------------+ ==> 1 row ==> ==> SchemaIndex(identifier="p", _db_hits=0, _rows=1, label="Player", query="Literal(Random Player)", property="name") ---- Based on a few runs of the query with and without the index defined it takes 1ms and 10ms respectively. The 'full node scan' approach takes ~ 40ms and that's with a very small database of 30,000 nodes. I wouldn't recommend it with a production load.

neo4j-2-0-labels-indexes-and-the-like

https://markhneedham.com/blog/2013/10/22/neo4j-2-0-labels-indexes-and-the-like

2013-10-22 22:02:14

Neo4j: Modelling hyper edges in a property graph

At the http://www.meetup.com/graphdb-belgium/[Graph Database meet up in Antwerp] last week we discussed how you would model a hyper edge in a property graph like Neo4j and I realised that I'd done this in my football graph without realising. A hyper edge is http://www.hyperedge.com.au/why-hyperedge[defined as follows]: ____ A hyperedge is a *connection between two or more vertices*, or nodes, of a hypergraph. A hypergraph is a graph in which generalized edges (called hyperedges) may connect more than two nodes with discrete properties. ____ In Neo4j an edge (or relationship) can only be between itself or another node, there's no way of creating a relationship between more than 2 nodes. I had problems when trying to model the relationship between a player and a football match because I wanted to say that a player participated in a match and represented a specific team in that match. I started out with the following model: image::{{<siteurl>}}/uploads/2013/10/2013-10-22_22-47-13.png[2013 10 22 22 47 13,600] Unfortunately creating a direct relationship from the player to the match means that there's no way to work out which team they played for. This information is useful because sometimes players transfer teams in the middle of a season and we want to analyse how they performed for each team. In a property graph we need to introduce an extra node which links the match, player and team together: image::{{<siteurl>}}/uploads/2013/10/2013-10-22_22-54-25.png[2013 10 22 22 54 25,600] Although we are forced to adopt this design it actually helps us *realise an extra entity* in our domain which wasn't visible before - a player's performance in a match. If we want to capture information about a players' performance in a match we can store it on this node. We can also easily aggregate players stats by following the +++<cite>+++played+++</cite>+++ relationship without needing to worry about the matches they played in. The Neo4j manual has a http://docs.neo4j.org/chunked/milestone/cypher-cookbook-hyperedges.html[few more examples of domain models containing hyper edges] which are worth having a look at if you want to learn more.

neo4j-modelling-hyper-edges-in-a-property-graph

https://markhneedham.com/blog/2013/10/22/neo4j-modelling-hyper-edges-in-a-property-graph

2013-10-25 16:03:48

Neo4j: Making implicit relationships explicit & bidirectional relationships

I recently read http://graphaware.com/neo4j/2013/10/11/neo4j-bidirectional-relationships.html[Michal Bachman's post about bidirectional relationships] in Neo4j in which he suggests that for some relationship types we're not that interested in the relationship's direction and can therefore ignore it when querying. He uses the following example showing the partnership between Neo Technology and GraphAware: image::{{<siteurl>}}/uploads/2013/10/neo_ga3.png[Neo ga3,492] Both companies are partners with each other but since we can just as quickly find incoming and outgoing relationships we may as well just have one relationship between the two companies/nodes. This pattern comes up frequently when we want to make implicit relationships in our graph explicit. For example, we might have the following graph which describes people and projects that they've worked on: image::{{<siteurl>}}/uploads/2013/10/2013-10-25_16-34-16.png[2013 10 25 16 34 16,600] We could create that graph in Neo4j 2.0 using the following cypher syntax: [source,cypher] ---- CREATE (mark:Person {name: "Mark"}) CREATE (dave:Person {name: "Dave"}) CREATE (john:Person {name: "John"}) CREATE (projectA:Project {name: "Project A"}) CREATE (projectB:Project {name: "Project B"}) CREATE (projectC:Project {name: "Project C"}) CREATE (mark)-[:WORKED_ON]->(projectA) CREATE (mark)-[:WORKED_ON]->(projectB) CREATE (dave)-[:WORKED_ON]->(projectA) CREATE (dave)-[:WORKED_ON]->(projectC) CREATE (john)-[:WORKED_ON]->(projectC) CREATE (john)-[:WORKED_ON]->(projectB) ---- If we wanted to work out which people know each other we could write the following query: [source,bash] ---- MATCH (person1:Person)-[:WORKED_ON]-()<-[:WORKED_ON]-(person2) RETURN person1, person2 ==> +-------------------------------------------------------+ ==> | person1 | person2 | ==> +-------------------------------------------------------+ ==> | Node[500363]{name:"Mark"} | Node[500364]{name:"Dave"} | ==> | Node[500363]{name:"Mark"} | Node[500365]{name:"John"} | ==> | Node[500364]{name:"Dave"} | Node[500363]{name:"Mark"} | ==> | Node[500364]{name:"Dave"} | Node[500365]{name:"John"} | ==> | Node[500365]{name:"John"} | Node[500364]{name:"Dave"} | ==> | Node[500365]{name:"John"} | Node[500363]{name:"Mark"} | ==> +-------------------------------------------------------+ ==> 6 rows ---- We might want to create a +++<cite>+++KNOWS+++</cite>+++ relationship between each pair of people: [source,cypher] ---- MATCH (person1:Person)-[:WORKED_ON]-()<-[:WORKED_ON]-(person2) CREATE UNIQUE (person1)-[:KNOWS]->(person2) RETURN person1, person2 ---- Now if we run a query (which ignores the relationship direction) to find out which people know each other we'll get a lot of duplicate results: [source,bash] ---- MATCH path=(person1:Person)-[:KNOWS]-(person2) RETURN person1, person2, path ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | person1 | person2 | path | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | Node[500363]{name:"Mark"} | Node[500364]{name:"Dave"} | [Node[500363]{name:"Mark"},:KNOWS[528536]{},Node[500364]{name:"Dave"}] | ==> | Node[500363]{name:"Mark"} | Node[500365]{name:"John"} | [Node[500363]{name:"Mark"},:KNOWS[528537]{},Node[500365]{name:"John"}] | ==> | Node[500363]{name:"Mark"} | Node[500364]{name:"Dave"} | [Node[500363]{name:"Mark"},:KNOWS[528538]{},Node[500364]{name:"Dave"}] | ==> | Node[500363]{name:"Mark"} | Node[500365]{name:"John"} | [Node[500363]{name:"Mark"},:KNOWS[528541]{},Node[500365]{name:"John"}] | ==> | Node[500364]{name:"Dave"} | Node[500363]{name:"Mark"} | [Node[500364]{name:"Dave"},:KNOWS[528538]{},Node[500363]{name:"Mark"}] | ==> | Node[500364]{name:"Dave"} | Node[500365]{name:"John"} | [Node[500364]{name:"Dave"},:KNOWS[528539]{},Node[500365]{name:"John"}] | ==> | Node[500364]{name:"Dave"} | Node[500363]{name:"Mark"} | [Node[500364]{name:"Dave"},:KNOWS[528536]{},Node[500363]{name:"Mark"}] | ==> | Node[500364]{name:"Dave"} | Node[500365]{name:"John"} | [Node[500364]{name:"Dave"},:KNOWS[528540]{},Node[500365]{name:"John"}] | ==> | Node[500365]{name:"John"} | Node[500364]{name:"Dave"} | [Node[500365]{name:"John"},:KNOWS[528540]{},Node[500364]{name:"Dave"}] | ==> | Node[500365]{name:"John"} | Node[500363]{name:"Mark"} | [Node[500365]{name:"John"},:KNOWS[528541]{},Node[500363]{name:"Mark"}] | ==> | Node[500365]{name:"John"} | Node[500363]{name:"Mark"} | [Node[500365]{name:"John"},:KNOWS[528537]{},Node[500363]{name:"Mark"}] | ==> | Node[500365]{name:"John"} | Node[500364]{name:"Dave"} | [Node[500365]{name:"John"},:KNOWS[528539]{},Node[500364]{name:"Dave"}] | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> 12 rows ---- Every pair of people shows up 4 times and if we take the example of Mark and Dave we can see why: [source,bash] ---- MATCH path=(person1:Person)-[:KNOWS]-(person2) WHERE person1.name = "Mark" AND person2.name = "Dave" RETURN person1, person2, path ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | person1 | person2 | path | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | Node[500363]{name:"Mark"} | Node[500364]{name:"Dave"} | [Node[500363]{name:"Mark"},:KNOWS[528536]{},Node[500364]{name:"Dave"}] | ==> | Node[500363]{name:"Mark"} | Node[500364]{name:"Dave"} | [Node[500363]{name:"Mark"},:KNOWS[528538]{},Node[500364]{name:"Dave"}] | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> 2 rows ---- If we look under the +++<cite>+++path+++</cite>+++ column there are two different +++<cite>+++KNOWS+++</cite>+++ relationships (with ids 528536 and 528538) between Mark and Dave, one going from Mark to Dave and the other from Dave to Mark. As Michal pointed out in his post having two relationships is unnecessary in this case. We only need a relationship one way, which we can do by not specifying a direction when we create the +++<cite>+++KNOWS+++</cite>+++ relationship: [source,bash] ---- MATCH (person1:Person)-[:WORKED_ON]-()<-[:WORKED_ON]-(person2) CREATE UNIQUE (person1)-[:KNOWS]-(person2) RETURN person1, person2 ---- Now if we re-run the query to check the relationships between Mark and Dave there is only one: [source,bash] ---- MATCH path=(person1:Person)-[:KNOWS]-(person2) WHERE person1.name = "Mark" AND person2.name = "Dave" RETURN person1, person2, path ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | person1 | person2 | path | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | Node[500375]{name:"Mark"} | Node[500376]{name:"Dave"} | [Node[500375]{name:"Mark"},:KNOWS[528560]{},Node[500376]{name:"Dave"}] | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> 1 row ---- The relationship goes from Mark to Dave in this case which we can see by executing some queries which take direction into account: [source,bash] ---- MATCH path=(person1:Person)-[:KNOWS]->(person2) WHERE person1.name = "Mark" AND person2.name = "Dave" RETURN person1, person2, path ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | person1 | person2 | path | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> | Node[500375]{name:"Mark"} | Node[500376]{name:"Dave"} | [Node[500375]{name:"Mark"},:KNOWS[528560]{},Node[500376]{name:"Dave"}] | ==> +--------------------------------------------------------------------------------------------------------------------------------+ ==> 1 row ---- [source,bash] ---- MATCH path=(person1:Person)<-[:KNOWS]-(person2) WHERE person1.name = "Mark" AND person2.name = "Dave" RETURN person1, person2, path ==> +--------------------------+ ==> | person1 | person2 | path | ==> +--------------------------+ ==> +--------------------------+ ==> 0 row ---- {blank}

neo4j-making-implicit-relationships-explicit-bidirectional-relationships

https://markhneedham.com/blog/2013/10/25/neo4j-making-implicit-relationships-explicit-bidirectional-relationships

2013-07-27 09:30:26

neo4j/cypher: Getting the hang of query parameters

For as long as I've been using http://www.neo4j.org/[neo4j]'s http://www.neo4j.org/learn/cypher[cypher] query language https://twitter.com/mesirii[Michael] has been telling me to use parameters in my queries but the performance of the queries was always acceptable so I didn't feel the need. However, recently I was playing around with a data set and I created ~500 nodes using code similar to this: [source,ruby] ---- require 'open-uri' open("data/people.cyp", 'w') { |f| (1..500).each do |value| f.puts("CREATE (p:Person{name: \"#{value}\"})") end } ---- That creates a file of cypher statements that look like this: [source,cypher] ---- CREATE (:Person{name: "person1"}) CREATE (:Person{name: "person2"}) CREATE (:Person{name: "person3"}) CREATE (:Person{name: "person4"}) CREATE (:Person{name: "person5"}) ... ---- If we execute those statements in the neo4j-shell or web admin we get the following output: [source,bash] ---- ==> +-------------------+ ==> | No data returned. | ==> +-------------------+ ==> Nodes created: 500 ==> Properties set: 500 ==> Labels added: 500 ==> 27706 ms ---- As far as I understand the reason it takes that long is that cypher creates and then caches a query plan for each create statement because it has no way of knowing that they are effectively the same. Since I was deleting/reloading the data quite frequently I wanted to make my feedback loop a bit quicker so it was finally time to apply Michael's advice. The way that parameters work is that you add placeholders into your cypher queries and then provide values that should reify those placeholders when you execute your query. In this case it seemed easiest to make use of https://github.com/maxdemarzi/neography[neography] to execute my query against a running neo4j server. If we want to create a single person with a parameterised name then we'd write the following code: [source,ruby] ---- require 'neography' params = { :name => "Mark" } Neography::Rest.new.execute_query("CREATE (:Person {name: {name} })", params) ---- If we run a query to get back all people we can see they've been successfully created: [source,bash] ---- neo4j-sh (0)$ match p:Person return p; ==> +----------------------+ ==> | p | ==> +----------------------+ ==> | Node[1]{name:"Mark"} | ==> +----------------------+ ==> 1 row ==> 175 ms ---- I wanted to pass in an array of names which I initially thought I could do but changing the value in the +++<cite>+++params+++</cite>+++ hash to an array: [source,ruby] ---- require 'neography' params = { :name => [] } (1..500).each do |value| params[:name] << "person#{value}" end Neography::Rest.new.execute_query("CREATE (:Person {name: {name} })", params) ---- I ran a query to get back my 500 people but only got one back: [source,bash] ---- neo4j-sh (0)$ MATCH p:Person RETURN p > ; ==> +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> | p | ==> +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> | Node[1]{name:["person1","person2","person3","person4","person5","person6","person7","person8","person9","person10","person11","person12","person13","person14","person15","person16","person17","person18","person19","person20","person21","person22","person23","person24","person25","person26","person27","person28","person29","person30","person31","person32","person33","person34","person35","person36","person37","person38","person39","person40","person41","person42","person43","person44","person45","person46","person47","person48","person49","person50","person51","person52","person53","person54","person55","person56","person57","person58","person59","person60","person61","person62","person63","person64","person65","person66","person67","person68","person69","person70","person71","person72","person73","person74","person75","person76","person77","person78","person79","person80","person81","person82","person83","person84","person85","person86","person87","person88","person89","person90","person91","person92","person93","person94","person95","person96","person97","person98","person99","person100","person101","person102","person103","person104","person105","person106","person107","person108","person109","person110","person111","person112","person113","person114","person115","person116","person117","person118","person119","person120","person121","person122","person123","person124","person125","person126","person127","person128","person129","person130","person131","person132","person133","person134","person135","person136","person137","person138","person139","person140","person141","person142","person143","person144","person145","person146","person147","person148","person149","person150","person151","person152","person153","person154","person155","person156","person157","person158","person159","person160","person161","person162","person163","person164","person165","person166","person167","person168","person169","person170","person171","person172","person173","person174","person175","person176","person177","person178","person179","person180","person181","person182","person183","person184","person185","person186","person187","person188","person189","person190","person191","person192","person193","person194","person195","person196","person197","person198","person199","person200","person201","person202","person203","person204","person205","person206","person207","person208","person209","person210","person211","person212","person213","person214","person215","person216","person217","person218","person219","person220","person221","person222","person223","person224","person225","person226","person227","person228","person229","person230","person231","person232","person233","person234","person235","person236","person237","person238","person239","person240","person241","person242","person243","person244","person245","person246","person247","person248","person249","person250","person251","person252","person253","person254","person255","person256","person257","person258","person259","person260","person261","person262","person263","person264","person265","person266","person267","person268","person269","person270","person271","person272","person273","person274","person275","person276","person277","person278","person279","person280","person281","person282","person283","person284","person285","person286","person287","person288","person289","person290","person291","person292","person293","person294","person295","person296","person297","person298","person299","person300","person301","person302","person303","person304","person305","person306","person307","person308","person309","person310","person311","person312","person313","person314","person315","person316","person317","person318","person319","person320","person321","person322","person323","person324","person325","person326","person327","person328","person329","person330","person331","person332","person333","person334","person335","person336","person337","person338","person339","person340","person341","person342","person343","person344","person345","person346","person347","person348","person349","person350","person351","person352","person353","person354","person355","person356","person357","person358","person359","person360","person361","person362","person363","person364","person365","person366","person367","person368","person369","person370","person371","person372","person373","person374","person375","person376","person377","person378","person379","person380","person381","person382","person383","person384","person385","person386","person387","person388","person389","person390","person391","person392","person393","person394","person395","person396","person397","person398","person399","person400","person401","person402","person403","person404","person405","person406","person407","person408","person409","person410","person411","person412","person413","person414","person415","person416","person417","person418","person419","person420","person421","person422","person423","person424","person425","person426","person427","person428","person429","person430","person431","person432","person433","person434","person435","person436","person437","person438","person439","person440","person441","person442","person443","person444","person445","person446","person447","person448","person449","person450","person451","person452","person453","person454","person455","person456","person457","person458","person459","person460","person461","person462","person463","person464","person465","person466","person467","person468","person469","person470","person471","person472","person473","person474","person475","person476","person477","person478","person479","person480","person481","person482","person483","person484","person485","person486","person487","person488","person489","person490","person491","person492","person493","person494","person495","person496","person497","person498","person499","person500"]} | ==> +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> 1 row ---- I'd actually made use of parameters in such a way that only one person got created and had their 'name' property set to an array of 500 names! I tweaked the code to pass in http://docs.neo4j.org/chunked/snapshot/query-create.html#create-create-multiple-nodes-from-map[an array of maps] instead of strings like so: [source,ruby] ---- require 'neography' params = { :people \=> [] } (1..500).each do |value| params[:people] << { :name \=> "person#\{value}"} end Neography::Rest.new.execute_query("CREATE (:Person \{people})", params) ---- I ran my script to populate the database before querying it again: [source, text] ---- neo4j-sh (0)$ MATCH p:Person RETURN p; =\=> +-----------------------------+ =\=> | p | =\=> +-----------------------------+ =\=> | Node[1]{name:"person1"} | =\=> | Node[2]{name:"person2"} | =\=> | Node[3]{name:"person3"} | =\=> | Node[4]{name:"person4"} | =\=> | Node[5]{name:"person5"} | =\=> | Node[6]{name:"person6"} | =\=> | Node[7]{name:"person7"} | =\=> | Node[8]{name:"person8"} | =\=> | Node[9]{name:"person9"} | =\=> | Node[10]{name:"person10"} | =\=> | Node[11]{name:"person11"} | \... =\=> +-----------------------------+ =\=> 500 rows =\=> 1081 ms ---- This time I got the expected result so the only thing to do was to quickly check how long it had taken to get the parameterised data into the database: [source, bash] ---- $ time bundle exec ruby people.rb real 0m0.993s user 0m0.733s sys 0m0.097s ---- And the winner is...Michael, by about 26 seconds per run. In this version cypher creates a query plan the first time it encounters the CREATE statement but after that it can use the query plan for the subsequent calls which leads to a massive performance improvement. http://www.apcjones.com/blog/[Alistair] pointed out that the query parameter approach is quite nice when used in applications because you don't need to worry about string concatenation, you can just change values in maps instead. Based on this experience I can now confirm https://twitter.com/maxdemarzi[Max De Marzi]'s tweet from last week: ____ Public Service Announcement for folks new to @https://twitter.com/neo4j[neo4j] and Cypher: Please use parameters in your queries http://docs.neo4j.org/chunked/milestone/cypher-parameters.html #MuchFaster ____

neo4jcypher-getting-the-hang-of-query-parameters

https://markhneedham.com/blog/2013/07/27/neo4jcypher-getting-the-hang-of-query-parameters

2013-07-27 11:21:52

Graph Processing: Betweeness Centrality - neo4j's cypher vs graphstream

Last week http://www.markhneedham.com/blog/2013/07/19/graph-processing-calculating-betweenness-centrality-for-an-undirected-graph-using-graphstream/[I wrote about the betweenness centrality algorithm and my attempts to understand it] using http://graphstream-project.org/[graphstream] and while reading the source I realised that I might be able to put something together using neo4j's http://docs.neo4j.org/chunked/stable/query-match.html#match-all-shortest-paths[all shortest paths] algorithm. To recap, the betweenness centrality algorithm is used to determine the load and importance of a node in a graph. While talking about this with https://twitter.com/jennifersmithco[Jen] she pointed out that calculating the betweenness centrality of nodes across the whole graph often doesn't make sense. However, it can be useful to know which node is the most important in a smaller sub graph that you're interested in. In this case I'm interested in working out the betweenness centrality of nodes in a very small directed graph: image:{{<siteurl>}}/uploads/2013/07/betweeness2.png[]</img> Let's briefly recap the algorithm: ____ [Betweenness centrality] is equal to the number of shortest paths from all vertices to all others that pass through that node. ____ This means that we exclude any paths which go directly between two nodes without passing through any others, something which I didn't initially grasp. If we work out the applicable paths by hand we end up with the following: [source,text] ---- A -> B: Direct Path Exists A -> C: B A -> D: E A -> E: Direct Path Exists B -> A: No Path Exists B -> C: Direct Path Exists B -> D: E or C B -> E: Direct Path Exists C -> A: No Path Exists C -> B: No Path Exists C -> D: Direct Path Exists C -> E: No Path Exists D -> A: No Path Exists D -> B: No Path Exists D -> C: No Path Exists D -> E: No Path Exists E -> A: No Path Exists E -> B: No Path Exists E -> C: No Path Exists E -> D: Direct Path Exists ---- Which gives the following betweenness centrality values: [source,text] ---- A: 0 B: 1 C: 0.5 D: 0 E: 1.5 ---- We can write a test against the latest version of https://github.com/graphstream/gs-algo[graphstream] (which takes direction into account) to confirm our manual algorithm: [source,java] ---- @Test public void calculateBetweennessCentralityOfMySimpleGraph() { Graph graph = new SingleGraph("Tutorial 1"); Node A = graph.addNode("A"); Node B = graph.addNode("B"); Node E = graph.addNode("E"); Node C = graph.addNode("C"); Node D = graph.addNode("D"); graph.addEdge("AB", A, B, true); graph.addEdge("BE", B, E, true); graph.addEdge("BC", B, C, true); graph.addEdge("ED", E, D, true); graph.addEdge("CD", C, D, true); graph.addEdge("AE", A, E, true); BetweennessCentrality bcb = new BetweennessCentrality(); bcb.computeEdgeCentrality(false); bcb.betweennessCentrality(graph); System.out.println("A="+ A.getAttribute("Cb")); System.out.println("B="+ B.getAttribute("Cb")); System.out.println("C="+ C.getAttribute("Cb")); System.out.println("D="+ D.getAttribute("Cb")); System.out.println("E="+ E.getAttribute("Cb")); } ---- The output is as expected: [source,text] ---- A=0.0 B=1.0 C=0.5 D=0.0 E=1.5 ---- I wanted to see if I could do the same thing using neo4j so I created the graph in a blank database using the following cypher statements: [source,cypher] ---- CREATE (A {name: "A"}) CREATE (B {name: "B"}) CREATE (C {name: "C"}) CREATE (D {name: "D"}) CREATE (E {name: "E"}) CREATE A-[:TO]->E CREATE A-[:TO]->B CREATE B-[:TO]->C CREATE B-[:TO]->E CREATE C-[:TO]->D CREATE E-[:TO]->D ---- I then wrote a query which found the shortest path between all sets of nodes in the graph: [source,cypher] ---- MATCH p = allShortestPaths(source-[r:TO*]->destination) WHERE source <> destination RETURN NODES(p) ---- If we run that it returns the following: [source,bash] ---- ==> +---------------------------------------------------------+ ==> | NODES(p) | ==> +---------------------------------------------------------+ ==> | [Node[1]{name:"A"},Node[2]{name:"B"}] | ==> | [Node[1]{name:"A"},Node[2]{name:"B"},Node[3]{name:"C"}] | ==> | [Node[1]{name:"A"},Node[5]{name:"E"},Node[4]{name:"D"}] | ==> | [Node[1]{name:"A"},Node[5]{name:"E"}] | ==> | [Node[2]{name:"B"},Node[3]{name:"C"}] | ==> | [Node[2]{name:"B"},Node[3]{name:"C"},Node[4]{name:"D"}] | ==> | [Node[2]{name:"B"},Node[5]{name:"E"},Node[4]{name:"D"}] | ==> | [Node[2]{name:"B"},Node[5]{name:"E"}] | ==> | [Node[3]{name:"C"},Node[4]{name:"D"}] | ==> | [Node[5]{name:"E"},Node[4]{name:"D"}] | ==> +---------------------------------------------------------+ ==> 10 rows ---- We're still returning the direct links between nodes but that's reasonably easy to correct by filtering the results based on the number of nodes in the path: [source,cypher] ---- MATCH p = allShortestPaths(source-[r:TO*]->destination) WHERE source <> destination AND LENGTH(NODES(p)) > 2 RETURN EXTRACT(n IN NODES(p): n.name) ---- [source,bash] ---- ==> +--------------------------------+ ==> | EXTRACT(n IN NODES(p): n.name) | ==> +--------------------------------+ ==> | ["A","B","C"] | ==> | ["A","E","D"] | ==> | ["B","C","D"] | ==> | ["B","E","D"] | ==> +--------------------------------+ ==> 4 rows ---- If we tweak the cypher query a bit we can get a collection of the shortest paths for each source/destination: [source,cypher] ---- MATCH p = allShortestPaths(source-[r:TO*]->destination) WHERE source <> destination AND LENGTH(NODES(p)) > 2 WITH EXTRACT(n IN NODES(p): n.name) AS nodes RETURN HEAD(nodes) AS source, HEAD(TAIL(TAIL(nodes))) AS destination, COLLECT(nodes) AS paths ---- [source,bash] ---- ==> +------------------------------------------------------+ ==> | source | destination | paths | ==> +------------------------------------------------------+ ==> | "A" | "D" | [["A","E","D"]] | ==> | "A" | "C" | [["A","B","C"]] | ==> | "B" | "D" | [["B","C","D"],["B","E","D"]] | ==> +------------------------------------------------------+ ==> 3 rows ---- When we have a way to slice collections using cypher it wouldn't be too difficult to get from here to a betweenness centrality score for the nodes but for now it's much easier to use a general programming language. In this case I used Ruby and came up with the following code: [source,ruby] ---- require 'neography' neo = Neography::Rest.new query = " MATCH p = allShortestPaths(source-[r:TO*]->destination)" query << " WHERE source <> destination AND LENGTH(NODES(p)) > 2" query << " WITH EXTRACT(n IN NODES(p): n.name) AS nodes" query << " RETURN HEAD(nodes) AS source, HEAD(TAIL(TAIL(nodes))) AS destination, COLLECT(nodes) AS paths" betweenness_centrality = { "A" => 0, "B" => 0, "C" => 0, "D" => 0, "E" => 0 } neo.execute_query(query)["data"].map { |row| row[2].map { |path| path[1..-2] } }.each do |potential_central_nodes| number_of_central_nodes = potential_central_nodes.size potential_central_nodes.each do |nodes| nodes.each { |node| betweenness_centrality[node] += (1.0 / number_of_central_nodes) } end end p betweenness_centrality ---- which outputs the following: [source,bash] ---- $ bundle exec ruby centrality.rb {"A"=>0, "B"=>1.0, "C"=>0.5, "D"=>0, "E"=>1.5} ---- It seems to do the job but I'm sure there are some corner cases it doesn't handle which a mature library would take care of. As an experiment to see what's possible I think it's not too bad though! The http://console.neo4j.org/?id=qwlyzd[graph is on the neo4j console] in case anyone is interested in playing around with it.

graph-processing-betweeness-centrality-neo4js-cypher-vs-graphstream

https://markhneedham.com/blog/2013/07/27/graph-processing-betweeness-centrality-neo4js-cypher-vs-graphstream

2013-07-16 08:13:02

Git: Commit squashing made even easier using 'git branch --set-upstream'

A few days ago I wrote a blog post describing how I wanted to http://www.markhneedham.com/blog/2013/07/13/gitgithub-squashing-all-commits-before-sending-a-pull-request/[squash a series of commits into one bigger one] before making a pull request and in the comments Rob Hunter showed me an even easier way to do so. To recap, by the end of the post I had the following git config: [source,bash] ---- $ cat .git/config [remote "origin"] fetch = +refs/heads/*:refs/remotes/origin/* url = git@github.com:mneedham/neo4j-shell-tools.git [branch "master"] remote = origin merge = refs/heads/master [remote "base"] url = git@github.com:jexp/neo4j-shell-tools.git fetch = +refs/heads/*:refs/remotes/base/* [branch "readme-pull"] remote = origin merge = refs/heads/readme-pull [branch "readme"] remote = origin merge = refs/heads/readme ---- I was working against the remote 'origin' but the actual home of this repository is 'base'. I'd created a load of commits on 'origin/readme' and had then squashed them all into one commit on 'origin/readme-pull' by using the following command: [source,bash] ---- $ git rebase -i c4e94f668223d53f6c7364d19aa965d09ea7eb00 ---- where 'c4e94f668223d53f6c7364d19aa965d09ea7eb00' is the hash of the last commit that was made in 'base/master'. Rob suggested that I should try using http://stackoverflow.com/questions/520650/how-do-you-make-an-existing-git-branch-track-a-remote-branch[upstream tracking] to simplify this even further. When we use upstream tracking we create a link between a local and remote repository which in this case is useful for working out where our commits start from. I thought I'd try it out on another branch. We want to set the new branch to track 'base/master' since that's the one we eventually want to have our commit applied against. We'll start from the 'readme' branch which has the list of commits that we want to squash [source,bash] ---- $ git branch master * readme readme-pull ---- Now let's create a new branch and then track it against 'base/master': [source,bash] ---- $ git checkout -b readme-pull-new Switched to a new branch 'readme-pull-new' $ git branch --set-upstream readme-pull-new base/master Branch readme-pull-new set up to track remote branch master from base. ---- Squashing all our commits is now as simple as running the following command: [source,bash] ---- $ git rebase -i ---- And then choosing 'squash' against all commits except for the first one which can stay as 'pick'. We then need to edit the commit message into shape which mostly involves deleting the commit messages from the commits we've squashed in this instance. Thanks to Rob for the tip!

git-commit-squashing-made-even-easier-using-git-branch-set-upstream

https://markhneedham.com/blog/2013/07/16/git-commit-squashing-made-even-easier-using-git-branch-set-upstream

2013-07-28 16:18:38

Product Documentation: The receiver decides if it's successful

One of the things I remember being taught while growing up is that in an interaction where somebody is something to someone else it's their responsibility to do so in a way that the receiver can understand. Even if you think you've done a good job of explaining something, the receiver of the communication decides whether or not that's the case. I'd always assumed that this advice made most sense in the context of a one to one conversation but recently I've realised that it also makes sense when thinking about product documentation. Most products on the market have some sort of documentation available which is a good first step but I've still seen a couple of ways that users of the product struggle: == It's too complicated Frequently documentation is written by an expert of the product so the language they use is very technical and difficult for a novice to understand. It's often worth running documentation past a non expert to get a sanity check but a tell tale sign that documentation may be too complicated is when you get a lot of questions about things that you believe it covers. At this point we can often work out what has led to user confusion and then make the appropriate changes. == People can't find it Sometimes there's no problem with the documentation but people can't find it. This might be because it's poorly titled or doesn't use the same language that users use when they are trying to solve a particular problem. There's a tendency to believe that users should learn the language of the domain and while that's true to an extent, if we can work out what language they use it can reduce friction and lead to a better experience. The other problem users encounter is where they find the documentation index but are then overwhelmed with information to the point where they're not sure what they should be clicking on. This can be solved by focusing documentation on the simple case but having links through to more advanced topics for people who are interested. == Further reading Tom Preston Werner wrote a post a few years ago around this topic titled 'http://tom.preston-werner.com/2010/08/23/readme-driven-development.html[Readme Driven Development]' which is worth a read. https://twitter.com/joewalnes[Joe Walnes] uses a similar approach on his projects - http://smoothiecharts.org/[Smoothie Charts] and http://webconnect.io/[WebConnect] are a couple of examples that I've come across.

product-documentation-the-receiver-decides-if-its-successful

https://markhneedham.com/blog/2013/07/28/product-documentation-the-receiver-decides-if-its-successful

2013-07-28 20:43:24

Jersey Client: Testing external calls

https://twitter.com/jimwebber[Jim] and I have been doing a bit of work over the last week which involved calling neo4j's http://docs.neo4j.org/chunked/stable/ha-rest-info.html[HA status URI to check whether or not an instance was a master/slave] and we've been using https://jersey.java.net/documentation/latest/user-guide.html#client[jersey-client]. The code looked roughly like this: [source,java] ---- class Neo4jInstance { private Client httpClient; private URI hostname; public Neo4jInstance(Client httpClient, URI hostname) { this.httpClient = httpClient; this.hostname = hostname; } public Boolean isSlave() { String slaveURI = hostname.toString() + ":7474/db/manage/server/ha/slave"; ClientResponse response = httpClient.resource(slaveURI).accept(TEXT_PLAIN).get(ClientResponse.class); return Boolean.parseBoolean(response.getEntity(String.class)); } } ---- While writing some tests against this code we wanted to stub out the actual calls to the HA slave URI so we could simulate both conditions and a brief search suggested that http://stackoverflow.com/questions/11005279/how-do-i-unit-test-code-which-calls-the-jersey-client-api[mockito was the way to go]. We ended up with a test that looked like this: [source,java] ---- @Test public void shouldIndicateInstanceIsSlave() { Client client = mock( Client.class ); WebResource webResource = mock( WebResource.class ); WebResource.Builder builder = mock( WebResource.Builder.class ); ClientResponse clientResponse = mock( ClientResponse.class ); when( builder.get( ClientResponse.class ) ).thenReturn( clientResponse ); when( clientResponse.getEntity( String.class ) ).thenReturn( "true" ); when( webResource.accept( anyString() ) ).thenReturn( builder ); when( client.resource( anyString() ) ).thenReturn( webResource ); Boolean isSlave = new Neo4jInstance(client, URI.create("http://localhost")).isSlave(); assertTrue(isSlave); } ---- which is pretty gnarly but does the job. I thought there must be a better way so I continued searching and eventually came across http://jersey.576304.n2.nabble.com/How-to-test-a-REST-client-Jersey-td5184618.html[this post on the mailing list] which suggested creating a custom ClientHandler and stubbing out requests/responses there. I had a go at doing that and wrapped it with a little DSL that only covers our very specific use case: [source,java] ---- private static ClientBuilder client() { return new ClientBuilder(); } static class ClientBuilder { private String uri; private int statusCode; private String content; public ClientBuilder requestFor(String uri) { this.uri = uri; return this; } public ClientBuilder returns(int statusCode) { this.statusCode = statusCode; return this; } public Client create() { return new Client() { public ClientResponse handle(ClientRequest request) throws ClientHandlerException { if (request.getURI().toString().equals(uri)) { InBoundHeaders headers = new InBoundHeaders(); headers.put("Content-Type", asList("text/plain")); return createDummyResponse(headers); } throw new RuntimeException("No stub defined for " + request.getURI()); } }; } private ClientResponse createDummyResponse(InBoundHeaders headers) { return new ClientResponse(statusCode, headers, new ByteArrayInputStream(content.getBytes()), messageBodyWorkers()); } private MessageBodyWorkers messageBodyWorkers() { return new MessageBodyWorkers() { public Map<MediaType, List<MessageBodyReader>> getReaders(MediaType mediaType) { return null; } public Map<MediaType, List<MessageBodyWriter>> getWriters(MediaType mediaType) { return null; } public String readersToString(Map<MediaType, List<MessageBodyReader>> mediaTypeListMap) { return null; } public String writersToString(Map<MediaType, List<MessageBodyWriter>> mediaTypeListMap) { return null; } public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> tClass, Type type, Annotation[] annotations, MediaType mediaType) { return (MessageBodyReader<T>) new StringProvider(); } public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> tClass, Type type, Annotation[] annotations, MediaType mediaType) { return null; } public <T> List<MediaType> getMessageBodyWriterMediaTypes(Class<T> tClass, Type type, Annotation[] annotations) { return null; } public <T> MediaType getMessageBodyWriterMediaType(Class<T> tClass, Type type, Annotation[] annotations, List<MediaType> mediaTypes) { return null; } }; } public ClientBuilder content(String content) { this.content = content; return this; } } ---- If we change our test to use this code it now looks like this: [source,java] ---- @Test public void shouldIndicateInstanceIsSlave() { Client client = client().requestFor("http://localhost:7474/db/manage/server/ha/slave"). returns(200). content("true"). create(); Boolean isSlave = new Neo4jInstance(client, URI.create("http://localhost")).isSlave(); assertTrue(isSlave); } ---- Is there a better way? In Ruby I've used https://github.com/bblimke/webmock[WebMock] to achieve this and https://twitter.com/a5hok[Ashok] pointed me towards https://github.com/tusharm/WebStub[WebStub] which looks nice except I'd need to pass in the hostname + port rather than constructing that in the code.

jersey-client-testing-external-calls

https://markhneedham.com/blog/2013/07/28/jersey-client-testing-external-calls

2013-07-19 00:37:41

Graph Processing: Calculating betweenness centrality for an undirected graph using graphstream

Since I now spend most of my time surrounded by http://www.neo4j.org/[graphs] I thought it'd be interesting to learn a bit more about http://jim.webber.name/2011/08/graph-processing-versus-graph-databases/[graph processing], a topic my colleague https://twitter.com/jimwebber[Jim] wrote about a couple of years ago. I like to think of the types of queries you'd do with a graph processing engine as being similar in style http://www.markhneedham.com/blog/2012/07/23/neo4j-graph-global-vs-graph-local-queries/[graph global queries] where you take most of the nodes in a graph into account and do some sort of calculation. One of the interesting graph global algorithms that I've come across recently is 'http://en.wikipedia.org/wiki/Betweenness_centrality[betweenness centrality]' which allows us to work out the centrality of each node with respect to the rest of the network/graph. ____ [Betweenness centrality] is equal to the number of shortest paths from all vertices to all others that pass through that node. Betweenness centrality is a more useful measure (than just connectivity) of both the load and importance of a node. The former is more global to the network, whereas the latter is only a local effect. ____ I wanted to find a library that I could play around with to get a better understanding of how this algorithm works and I came across http://graphstream-project.org/doc/Algorithms/Betweenness-Centrality_1.0/[graphstream] which seems to do the job. I was able to get up and running by creating a Maven pom file with the following dependencies: [source,xml] ---- <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <packaging>jar</packaging> <artifactId>my-gs-project</artifactId> <groupId>org.graphstream</groupId> <version>1.0-SNAPSHOT</version> <name>my-gs-project</name> <description/> <dependencies> <dependency> <groupId>org.graphstream</groupId> <artifactId>gs-core</artifactId> <version>1.0</version> </dependency> <dependency> <groupId>org.graphstream</groupId> <artifactId>gs-algo</artifactId> <version>1.0</version> </dependency> </dependencies> </project> ---- I wanted to find a worked example which I could use to understand how betweenness centrality is calculated and I found one on http://www.cse.unr.edu/~mgunes/cs765/cs790f09/Lecture13.ppt[slide 14 of these lecture notes] from The University of Nevada. The example graph looks like this: image::{{<siteurl>}}/uploads/2013/07/betweeness.png[Betweeness,500] And to work out the betweenness centrality we need to take every pair of nodes and see which (if any) nodes a path between the two must pass through. [source,text] ---- A -> B: None A -> C: B A -> D: B, C A -> E: B, C, D B -> C: None B -> D: C B -> E: C, D C -> D: None C -> E: D D -> E: None ---- So for this example we end up with the following centrality values for each node:~~~ ~~~text A: 0 B: 3 C: 4 D: 3 E: 0 ~~~ If we run this through graph stream we'll see values double to this because it ignores the direction of a relationship (e.g. it's possible to go from B\->A even though that relationship is actually only from A\->B.): ~~~java public class Spike { public static void main(String[] args) { Graph graph = new SingleGraph("Tutorial 1"); Node A = graph.addNode("A"); Node B = graph.addNode("B"); Node E = graph.addNode("E"); Node C = graph.addNode("C"); Node D = graph.addNode("D"); graph.addEdge("AB", "A", "B"); graph.addEdge("BC", "B", "C"); graph.addEdge("CD", "C", "D"); graph.addEdge("DE", "D", "E"); BetweennessCentrality bcb = new BetweennessCentrality(); bcb.init(graph); bcb.compute(); System.out.println("A="+ A.getAttribute("Cb")); System.out.println("B="+ B.getAttribute("Cb")); System.out.println("C="+ C.getAttribute("Cb")); System.out.println("D="+ D.getAttribute("Cb")); System.out.println("E="+ E.getAttribute("Cb")); } } ~~~ ~~~text A=0.0 B=6.0 C=8.0 D=6.0 E=0.0 ~~~ What we can learn from this calculation is that in this graph node 'C' is the most influential one because most paths between other nodes have to pass through it. There's not much in it though as nodes 'B' and 'D' are close behind. Now that I had a better understanding of how to manually execute the algorithm I thought I should try and work out what the example from the http://graphstream-project.org/doc/Algorithms/Betweenness-Centrality_1.0/[documentation] would return. The example graph looks like this: image::{{<siteurl>}}/uploads/2013/07/betweeness2.png[Betweeness2,500] And the paths between the nodes would be as follows: _Since I know graphstream treats the graph as being undirected I don't respect the direction of relationships in this calculation)_ ~~~text A \-> B: Direct Path Exists A \-> C: B A \-> D: E A \-> E: Direct Path Exists B \-> A: Direct Path Exists B \-> C: Direct Path Exists B \-> D: E or C B \-> E: Direct Path Exists C \-> A: B C \-> B: Direct Path Exists C \-> D: Direct Path Exists C \-> E: D or B D \-> A: E D \-> B: C or E D \-> C: Direct Path Exists D \-> E: Direct Path Exists E \-> A: Direct Path Exists E \-> B: Direct Path Exists E \-> C: D or B E \-> D: Direct Path Exists ~~~ For some of these there were two potential paths so we give 1/2 a point to each node which leads to these totals ~~~text A: 0 B: 3 C: 1 D: 1 E: 3 ~~~ If we run that through graphstream we'd expect to see the same values: ~~~java public class Spike { public static void main(String[] args) { Graph graph = new SingleGraph("Tutorial 1"); Node A = graph.addNode("A"); Node B = graph.addNode("B"); Node E = graph.addNode("E"); Node C = graph.addNode("C"); Node D = graph.addNode("D"); graph.addEdge("AB", "A", "B"); graph.addEdge("BE", "B", "E"); graph.addEdge("BC", "B", "C"); graph.addEdge("ED", "E", "D"); graph.addEdge("CD", "C", "D"); graph.addEdge("AE", "A", "E"); BetweennessCentrality bcb = new BetweennessCentrality(); bcb.init(graph); bcb.compute(); System.out.println("A="+ A.getAttribute("Cb")); System.out.println("B="+ B.getAttribute("Cb")); System.out.println("C="+ C.getAttribute("Cb")); System.out.println("D="+ D.getAttribute("Cb")); System.out.println("E="+ E.getAttribute("Cb")); } } ~~~ ~~~text A=0.0 B=3.0 C=1.0 D=1.0 E=3.0 ~~~ This library does the job for some definition of betweenness centrality but ideally I'd like to have the direction of relationships taken into account so I'm going to give it a try with one of the other libraries that I've come across. So far the other graph processing libraries I know of are http://graphlab.org/graphchi/[graphchi], http://jung.sourceforge.net/[JUNG], https://github.com/stanford-ppl/Green-Marl[Green-Marl] and http://giraph.apache.org/[giraph] but if you know of any others that I should try out please let me know. *** Update ** (27th July 2013)* While http://www.markhneedham.com/blog/2013/07/27/graph-processing-betweeness-centrality-neo4js-cypher-vs-graphstream/[writing another post] about betweenness centrality I realised I'd made a mistake in the calculations on this post so I've corrected those now.

graph-processing-calculating-betweenness-centrality-for-an-undirected-graph-using-graphstream

https://markhneedham.com/blog/2013/07/19/graph-processing-calculating-betweenness-centrality-for-an-undirected-graph-using-graphstream

2013-07-21 10:37:45

Jersey Server: com.sun.jersey.api.MessageException: A message body writer for Java class org.codehaus.jackson.node.ObjectNode and MIME media type application/json was not found

I've been http://www.markhneedham.com/blog/2012/11/28/jersey-com-sun-jersey-api-client-clienthandlerexception-a-message-body-reader-for-java-class-and-mime-media-type-applicationjson-was-not-found/[reacquainted] with my good friend https://jersey.java.net/[Jersey] over the last couple of days and in getting up and running was reminded that things which seemed easy at the time aren't as easy when starting from scratch. I eventually settled on using https://github.com/sunnygleason[Sunny Gleason]'s https://github.com/sunnygleason/j4-minimal[j4-minimal] repository which wires up Jersey with Jackson, Guice and Jetty which seemed like a good place to start. I prefer building up JSON objects explicitly rather than setting up automatic mapping so the first thing I did was change the +++<cite>+++https://github.com/sunnygleason/j4-minimal/blob/master/src/main/java/com/g414/j4/minimal/JacksonResource.java[JacksonResource]+++</cite>+++ to have an end point that returned a manually built up JSON object: [source,java] ---- @Path("/jackson") public class JacksonResource { @GET @Produces( { MediaType.APPLICATION_JSON }) @Path("/awesome/{who}") public Response sayOtherGreeting(@PathParam("who") String name) { ObjectNode result = JsonNodeFactory.instance.objectNode(); result.put("name", name); return Response.ok().entity(result).build(); } } ---- When I tried to hit that in the browser I ended up with the following exception: [source,text] ---- SEVERE: The registered message body writers compatible with the MIME media type are: application/json -> com.sun.jersey.json.impl.provider.entity.JSONJAXBElementProvider$App com.sun.jersey.json.impl.provider.entity.JSONArrayProvider$App com.sun.jersey.json.impl.provider.entity.JSONObjectProvider$App com.sun.jersey.json.impl.provider.entity.JSONRootElementProvider$App com.sun.jersey.json.impl.provider.entity.JSONListElementProvider$App */* -> com.sun.jersey.core.impl.provider.entity.FormProvider com.sun.jersey.server.impl.template.ViewableMessageBodyWriter com.sun.jersey.core.impl.provider.entity.StringProvider com.sun.jersey.core.impl.provider.entity.ByteArrayProvider com.sun.jersey.core.impl.provider.entity.FileProvider com.sun.jersey.core.impl.provider.entity.InputStreamProvider com.sun.jersey.core.impl.provider.entity.DataSourceProvider com.sun.jersey.core.impl.provider.entity.XMLJAXBElementProvider$General com.sun.jersey.core.impl.provider.entity.ReaderProvider com.sun.jersey.core.impl.provider.entity.DocumentProvider com.sun.jersey.core.impl.provider.entity.StreamingOutputProvider com.sun.jersey.core.impl.provider.entity.SourceProvider$SourceWriter com.sun.jersey.json.impl.provider.entity.JSONJAXBElementProvider$General com.sun.jersey.json.impl.provider.entity.JSONArrayProvider$General com.sun.jersey.json.impl.provider.entity.JSONObjectProvider$General com.sun.jersey.json.impl.provider.entity.JSONWithPaddingProvider com.sun.jersey.core.impl.provider.entity.XMLRootElementProvider$General com.sun.jersey.core.impl.provider.entity.XMLListElementProvider$General com.sun.jersey.json.impl.provider.entity.JSONRootElementProvider$General com.sun.jersey.json.impl.provider.entity.JSONListElementProvider$General com.sun.jersey.json.impl.provider.entity.JacksonProviderProxy Jul 21, 2013 11:11:17 AM com.sun.jersey.spi.container.ContainerResponse logException SEVERE: Mapped exception to response: 500 (Internal Server Error) javax.ws.rs.WebApplicationException: com.sun.jersey.api.MessageException: A message body writer for Java class org.codehaus.jackson.node.ObjectNode, and Java type class org.codehaus.jackson.node.ObjectNode, and MIME media type application/json was not found at com.sun.jersey.spi.container.ContainerResponse.write(ContainerResponse.java:285) at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1451) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1363) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1353) at com.sun.jersey.spi.container.servlet.WebComponent.service(WebComponent.java:414) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:537) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:708) at javax.servlet.http.HttpServlet.service(HttpServlet.java:848) at com.google.inject.servlet.ServletDefinition.doService(ServletDefinition.java:263) at com.google.inject.servlet.ServletDefinition.service(ServletDefinition.java:178) at com.google.inject.servlet.ManagedServletPipeline.service(ManagedServletPipeline.java:91) at com.google.inject.servlet.FilterChainInvocation.doFilter(FilterChainInvocation.java:62) at com.google.inject.servlet.ManagedFilterPipeline.dispatch(ManagedFilterPipeline.java:118) at com.google.inject.servlet.GuiceFilter.doFilter(GuiceFilter.java:113) at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1338) at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:484) at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:231) at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:1065) at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:413) at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:192) at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:999) at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:117) at org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:111) at org.eclipse.jetty.server.Server.handle(Server.java:350) at org.eclipse.jetty.server.AbstractHttpConnection.handleRequest(AbstractHttpConnection.java:454) at org.eclipse.jetty.server.AbstractHttpConnection.headerComplete(AbstractHttpConnection.java:890) at org.eclipse.jetty.server.AbstractHttpConnection$RequestHandler.headerComplete(AbstractHttpConnection.java:944) at org.eclipse.jetty.http.HttpParser.parseNext(HttpParser.java:630) at org.eclipse.jetty.http.HttpParser.parseAvailable(HttpParser.java:230) at org.eclipse.jetty.server.AsyncHttpConnection.handle(AsyncHttpConnection.java:77) at org.eclipse.jetty.io.nio.SelectChannelEndPoint.handle(SelectChannelEndPoint.java:606) at org.eclipse.jetty.io.nio.SelectChannelEndPoint$1.run(SelectChannelEndPoint.java:46) at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:603) at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:538) at java.lang.Thread.run(Thread.java:722) Caused by: com.sun.jersey.api.MessageException: A message body writer for Java class org.codehaus.jackson.node.ObjectNode, and Java type class org.codehaus.jackson.node.ObjectNode, and MIME media type application/json was not found ... 35 more ---- This is exactly the same problem that I http://www.markhneedham.com/blog/2012/11/28/jersey-com-sun-jersey-api-client-clienthandlerexception-a-message-body-reader-for-java-class-and-mime-media-type-applicationjson-was-not-found/[wrote about last year with respect to Jersey Client]. It took me a little while but I eventually found a solution to the problem hidden about half way down http://stackoverflow.com/questions/13108161/a-message-body-writer-for-java-class-not-found[a StackOverflow post for a similar exception]. We need to add the following property to our Jersey config: [source,java] ---- Map<String, Object> config = new HashMap<String, Object>(); config.put("com.sun.jersey.api.json.POJOMappingFeature", true); ---- If we https://github.com/mneedham/j4-minimal/commit/b2b4ab44da2286cdc0ff3a079ec399b1e5286438[edit the SampleConfig from the template] it will now look like this: [source,java] ---- public class SampleConfig extends GuiceServletContextListener { @Override protected Injector getInjector() { return Guice.createInjector(new ServletModule() { @Override protected void configureServlets() { /* bind the REST resources */ bind(BenchResource.class); bind(SampleResource.class); bind(JacksonResource.class); /* bind jackson converters for JAXB/JSON serialization */ bind(MessageBodyReader.class).to(JacksonJsonProvider.class); bind(MessageBodyWriter.class).to(JacksonJsonProvider.class); Map<String, String> initParams = new HashMap<String, String>(); initParams.put("com.sun.jersey.config.feature.Trace", "true"); initParams.put("com.sun.jersey.api.json.POJOMappingFeature", "true"); serve("*").with( GuiceContainer.class, initParams); } }); } } ---- If we hit '/jackson/awesome/mark' it now returns JSON as expected: [source,bash] ---- $ curl http://localhost:8080/jackson/awesome/mark -w "\n" {"name":"mark"} ----

jersey-server-com-sun-jersey-api-messageexception-a-message-body-writer-for-java-class-org-codehaus-jackson-node-objectnode-and-mime-media-type-applicationjson-was-not-found

https://markhneedham.com/blog/2013/07/21/jersey-server-com-sun-jersey-api-messageexception-a-message-body-writer-for-java-class-org-codehaus-jackson-node-objectnode-and-mime-media-type-applicationjson-was-not-found

2013-07-21 11:07:11

Jersey: Listing all resources, paths, verbs to build an entry point/index for an API

I've been playing around with https://jersey.java.net/[Jersey] over the past couple of days and one thing I wanted to do was create an entry point or index which listed all my resources, the available paths and the verbs they accepted. http://stackoverflow.com/users/1657364/guido-simone[Guido Simone] explained http://stackoverflow.com/questions/13484350/find-a-list-of-all-jersey-resource-methods-in-my-app[a neat way of finding the paths and verbs for a specific resource] using Jersey's +++<cite>+++http://grepcode.com/file/repo1.maven.org/maven2/com.sun.jersey/jersey-server/1.0.3/com/sun/jersey/server/impl/modelapi/annotation/IntrospectionModeller.java[IntrospectionModeller]+++</cite>+++: [source,java] ---- AbstractResource resource = IntrospectionModeller.createResource(JacksonResource.class); System.out.println("Path is " + resource.getPath().getValue()); String uriPrefix = resource.getPath().getValue(); for (AbstractSubResourceMethod srm :resource.getSubResourceMethods()) { String uri = uriPrefix + "/" + srm.getPath().getValue(); System.out.println(srm.getHttpMethod() + " at the path " + uri + " return " + srm.getReturnType().getName()); } ---- If we run that against https://github.com/mneedham/j4-minimal[j4-minimal]'s +++<cite>+++https://github.com/mneedham/j4-minimal/blob/master/src/main/java/com/g414/j4/minimal/JacksonResource.java[JacksonResource]+++</cite>+++ class we get the following output: [source,text] ---- Path is /jackson GET at the path /jackson/{who} return com.g414.j4.minimal.JacksonResource$Greeting GET at the path /jackson/awesome/{who} return javax.ws.rs.core.Response ---- That's pretty neat but I didn't want to have to manually list all my resources since I've already done that using Guice . I needed a way to programatically get hold of them and I partially found the way to do this from http://stackoverflow.com/questions/3132944/javaee6rest-how-do-i-get-all-rest-resources-at-runtime[this post] which suggests using +++<cite>+++Application.getSingletons()+++</cite>+++. I actually ended up using +++<cite>+++Application.getClasses()+++</cite>+++ and I ended up with +++<cite>+++https://github.com/mneedham/j4-minimal/blob/249078d2c8e982b81ae810310eb2340fa4fd909f/src/main/java/com/g414/j4/minimal/ResourceListingResource.java[ResourceListingResource]+++</cite>+++: [source,java] ---- @Path("/") public class ResourceListingResource { @GET @Produces(MediaType.APPLICATION_JSON) public Response showAll( @Context Application application, @Context HttpServletRequest request) { String basePath = request.getRequestURL().toString(); ObjectNode root = JsonNodeFactory.instance.objectNode(); ArrayNode resources = JsonNodeFactory.instance.arrayNode(); root.put( "resources", resources ); for ( Class<?> aClass : application.getClasses() ) { if ( isAnnotatedResourceClass( aClass ) ) { AbstractResource resource = IntrospectionModeller.createResource( aClass ); ObjectNode resourceNode = JsonNodeFactory.instance.objectNode(); String uriPrefix = resource.getPath().getValue(); for ( AbstractSubResourceMethod srm : resource.getSubResourceMethods() ) { String uri = uriPrefix + "/" + srm.getPath().getValue(); addTo( resourceNode, uri, srm, joinUri(basePath, uri) ); } for ( AbstractResourceMethod srm : resource.getResourceMethods() ) { addTo( resourceNode, uriPrefix, srm, joinUri( basePath, uriPrefix ) ); } resources.add( resourceNode ); } } return Response.ok().entity( root ).build(); } private void addTo( ObjectNode resourceNode, String uriPrefix, AbstractResourceMethod srm, String path ) { if ( resourceNode.get( uriPrefix ) == null ) { ObjectNode inner = JsonNodeFactory.instance.objectNode(); inner.put("path", path); inner.put("verbs", JsonNodeFactory.instance.arrayNode()); resourceNode.put( uriPrefix, inner ); } ((ArrayNode) resourceNode.get( uriPrefix ).get("verbs")).add( srm.getHttpMethod() ); } private boolean isAnnotatedResourceClass( Class rc ) { if ( rc.isAnnotationPresent( Path.class ) ) { return true; } for ( Class i : rc.getInterfaces() ) { if ( i.isAnnotationPresent( Path.class ) ) { return true; } } return false; } } ---- The only change I've made from Guido Simone's solution is that I also call +++<cite>+++resource.getResourceMethods()+++</cite>+++ because +++<cite>+++resource.getSubResourceMethods()+++</cite>+++ only returns methods which have a +++<cite>+++@Path+++</cite>+++ annotation. Since we'll sometimes define our path at the class level and then define different verbs that operate on that resource it misses some methods out. If we run a cURL command (http://stackoverflow.com/questions/352098/how-to-pretty-print-json-from-the-command-line[piped through python to make it look nice]) against the root we get the following output: [source,bash] ---- $ curl http://localhost:8080/ -w "\n" 2>/dev/null | python -mjson.tool { "resources": [ { "/bench": { "path": "http://localhost:8080/bench", "verbs": [ "GET", "POST", "PUT", "DELETE" ] } }, { "/sample/{who}": { "path": "http://localhost:8080/sample/{who}", "verbs": [ "GET" ] } }, { "/jackson/awesome/{who}": { "path": "http://localhost:8080/jackson/awesome/{who}", "verbs": [ "GET" ] }, "/jackson/{who}": { "path": "http://localhost:8080/jackson/{who}", "verbs": [ "GET" ] } }, { "/": { "path": "http://localhost:8080/", "verbs": [ "GET" ] } } ] } ----

jersey-listing-all-resources-paths-verbs-to-build-an-entry-pointindex-for-an-api

https://markhneedham.com/blog/2013/07/21/jersey-listing-all-resources-paths-verbs-to-build-an-entry-pointindex-for-an-api

2013-07-31 06:21:42

AWS: Attaching an EBS volume on an EC2 instance and making it available for use

I recently wanted to attach an EBS volume to an existing EC2 instance that I had running and since it was for a one off tasks (famous last words) I decided to configure it manually. I created the EBS volume through the AWS console and one thing that initially caught me out is that the EC2 instance and EBS volume need to be in the *same region and zone*. Therefore if I create my EC2 instance in 'eu-west-1b' then I need to create my EBS volume in 'eu-west-1b' as well otherwise I won't be able to attach it to that instance. I attached the device as +++<cite>+++/dev/sdf+++</cite>+++ although the UI gives the following warning: ____ Linux Devices: /dev/sdf through /dev/sdp Note: Newer linux kernels may rename your devices to /dev/xvdf through /dev/xvdp internally, even when the device name entered here (and shown in the details) is /dev/sdf through /dev/sdp. ____ After attaching the EBS volume to the EC2 instance my next step was to SSH onto my EC2 instance and http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-using-volumes.html[make the EBS volume available]. The first step is to create a file system on the volume: [source,bash] ---- $ sudo mkfs -t ext3 /dev/sdf mke2fs 1.42 (29-Nov-2011) Could not stat /dev/sdf --- No such file or directory The device apparently does not exist; did you specify it correctly? ---- It turns out that warning was handy and the device has in fact been renamed. We can confirm this by calling +++<cite>+++fdisk+++</cite>+++: [source,bash] ---- $ sudo fdisk -l Disk /dev/xvda1: 8589 MB, 8589934592 bytes 255 heads, 63 sectors/track, 1044 cylinders, total 16777216 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x00000000 Disk /dev/xvda1 doesn't contain a valid partition table Disk /dev/xvdf: 53.7 GB, 53687091200 bytes 255 heads, 63 sectors/track, 6527 cylinders, total 104857600 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x00000000 Disk /dev/xvdf doesn't contain a valid partition table ---- +++<cite>+++/dev/xvdf+++</cite>+++ is the one we're interested in so I re-ran the previous command: [source,bash] ---- $ sudo mkfs -t ext3 /dev/xvdf mke2fs 1.42 (29-Nov-2011) Filesystem label= OS type: Linux Block size=4096 (log=2) Fragment size=4096 (log=2) Stride=0 blocks, Stripe width=0 blocks 3276800 inodes, 13107200 blocks 655360 blocks (5.00%) reserved for the super user First data block=0 Maximum filesystem blocks=4294967296 400 block groups 32768 blocks per group, 32768 fragments per group 8192 inodes per group Superblock backups stored on blocks: 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 4096000, 7962624, 11239424 Allocating group tables: done Writing inode tables: done Creating journal (32768 blocks): done Writing superblocks and filesystem accounting information: done ---- Once I'd done that I needed to create a mount point for the volume and I thought the best place was probably a directory under +++<cite>+++/mnt+++</cite>+++: [source,bash] ---- $ sudo mkdir /mnt/ebs ---- The final step is to mount the volume: [source,bash] ---- $ sudo mount /dev/xvdf /mnt/ebs ---- And if we run +++<cite>+++df+++</cite>+++ we can see that it's ready to go: [source,bash] ---- $ df -h Filesystem Size Used Avail Use% Mounted on /dev/xvda1 7.9G 883M 6.7G 12% / udev 288M 8.0K 288M 1% /dev tmpfs 119M 164K 118M 1% /run none 5.0M 0 5.0M 0% /run/lock none 296M 0 296M 0% /run/shm /dev/xvdf 50G 180M 47G 1% /mnt/ebs ----

aws-attaching-an-ebs-volume-on-an-ec2-instance-and-making-it-available-for-use

https://markhneedham.com/blog/2013/07/31/aws-attaching-an-ebs-volume-on-an-ec2-instance-and-making-it-available-for-use

2013-07-31 05:41:12

Getting started with screen

Last week I had a ~10GB file I wanted to download to my machine but Chrome's initial estimate was that it would take 10+ hours to do so which meant I'd have probably shutdown my machine before it had completed. It seemed to make more sense to spin up an EC2 instance and download it onto there instead but I didn't want to have to keep an SSH session open to that machine either. I've previously come across http://www.gnu.org/software/screen/[screen] and http://tmux.sourceforge.net/[tmux] which allow you to create a session in which you can do some work even if you aren't currently connected to it which was perfect for my use case. screen was a bit more familiar so I decided to use that and I thought I should make a quick note of some of its basic flags for future me. == Starting a new session Starting a new screen session is as simple as typing the following command: [source,bash] ---- $ screen ---- which leads to the following output: [source,bash] ---- Screen version 4.00.03jw4 (FAU) 2-May-06 Copyright (c) 1993-2002 Juergen Weigert, Michael Schroeder Copyright (c) 1987 Oliver Laumann This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. ... ---- We can now start downloading our file using cURL, wget or a download accelerator like http://freecode.com/projects/axel[axel] which is my personal favourite. == Detaching/Exiting from a session without it dying Once I'd got the download running I wanted to close my SSH session to the AWS instance but first I wanted to detach from my screen session without killing it. My first attempt was to use +++<cite>+++Ctrl + D+++</cite>+++ but that actually results in the session being terminated and our download is therefore stopped as well which isn't quite what we wanted. Instead what we want to do is http://www.gnu.org/software/screen/manual/screen.html#Detach[detach] from the session which allows us to http://stackoverflow.com/questions/4847691/how-do-i-get-out-of-a-screen-without-typing-exit[leave it but keep it running]. To do that we type +++<cite>+++Ctrl + A+++</cite>+++ followed by +++<cite>+++Ctrl + D+++</cite>+++. == Reattaching to a session After about an hour I wanted to checkup on my download and I assumed just typing +++<cite>+++screen+++</cite>+++ would take me back to my session but instead it created a new one. http://www.apcjones.com/blog/[Alistair] pointed out that I could get a listing of all the open screen sessions by typing the following command: [source,bash] ---- $ screen -ls There are screens on: 23397.pts-0.ip-10-243-5-102 (07/31/2013 05:25:30 AM) (Detached) 3981.pts-0.ip-10-243-5-102 (07/26/2013 07:59:28 AM) (Detached) 3910.pts-0.ip-10-243-5-102 (07/26/2013 07:58:42 AM) (Detached) 1094.pts-0.ip-10-243-5-102 (07/26/2013 07:49:31 AM) (Detached) 4 Sockets in /var/run/screen/S-ubuntu. ---- As you can see, I'd created a bunch of extra sessions by mistake. The one I had the download running on was '1094.pts-0.ip-10-243-5-102' and we can reattach to that one like this: [source,bash] ---- $ screen -x 1094.pts-0.ip-10-243-5-102 ---- We can also attach using the '-r' flag: [source,bash] ---- $ screen -r 1094.pts-0.ip-10-243-5-102 ---- I'm not quite sure what the difference is between '-r' and '-x', they both seem to behave in the same way in this scenario. The manual suggests that '-x' is for attaching to a 'not detached screen session' which suggests to me that it shouldn't have worked since I wanted to connect to a detached session. Hopefully someone with more knowledge of how these things work can explain what's going on! == Attach to an existing session or start a new one if none exists I http://serverfault.com/questions/38417/reattach-or-create-a-named-screen-session-or-persistent-screen-sessions[later learnt] that had I not accidentally created all those extra sessions the following command would have been quite useful for finding the first screen session available and connecting to it: [source,bash] ---- $ screen -x -R ---- If there aren't any existing screen sessions available then it will create a new one which means that in my particular situation this would have been a more appropriate command to start with.

getting-started-with-screen

https://markhneedham.com/blog/2013/07/31/getting-started-with-screen

2013-07-30 16:20:16

s3cmd: put fails with "`Connection reset by peer`" for large files

I recently wanted to copy some large files from an AWS instance into an S3 bucket using http://s3tools.org/[s3cmd] but ended up with the following error when trying to use the 'put' command: [source,bash] ---- $ s3cmd put /mnt/ebs/myfile.tar s3://mybucket.somewhere.com /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 1077248 of 12185313280 0% in 1s 937.09 kB/s failed WARNING: Upload failed: /myfile.tar ([Errno 104] Connection reset by peer) WARNING: Retrying on lower speed (throttle=0.00) WARNING: Waiting 3 sec... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 1183744 of 12185313280 0% in 1s 1062.18 kB/s failed WARNING: Upload failed: /myfile.tar ([Errno 104] Connection reset by peer) WARNING: Retrying on lower speed (throttle=0.01) WARNING: Waiting 6 sec... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 417792 of 12185313280 0% in 1s 378.75 kB/s failed WARNING: Upload failed: /myfile.tar ([Errno 104] Connection reset by peer) WARNING: Retrying on lower speed (throttle=0.05) WARNING: Waiting 9 sec... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 94208 of 12185313280 0% in 1s 81.04 kB/s failed WARNING: Upload failed: /myfile.tar ([Errno 32] Broken pipe) WARNING: Retrying on lower speed (throttle=0.25) WARNING: Waiting 12 sec... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 28672 of 12185313280 0% in 1s 18.40 kB/s failed WARNING: Upload failed: /myfile.tar ([Errno 32] Broken pipe) WARNING: Retrying on lower speed (throttle=1.25) WARNING: Waiting 15 sec... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [1 of 1] 12288 of 12185313280 0% in 2s 4.41 kB/s failed ERROR: Upload of '/mnt/ebs/myfile.tar' failed too many times. Skipping that file. ---- I tried with a smaller file just to make sure I wasn't doing anything stupid syntax wise and that transferred without a problem which lead me to believe the problem might be when uploading larger files - the one I was uploading was around ~10GB in size. I eventually came across http://serverfault.com/questions/514861/s3put-fails-with-connection-reset-by-peer-for-large-files[this StackOverflow thread] which suggested that files >5GB in size need to make use of the 'multi part method' which was released in http://s3tools.org/s3cmd-110b2-released[version 1.1.0 of s3cmd]. The Ubuntu repository comes with version 1.0.0 so I needed to find a way of getting a newer version onto the machine. I eventually ended up downloading http://sourceforge.net/projects/s3tools/files/s3cmd/1.5.0-alpha3/[version 1.5.0 from sourceforge] but I couldn't get a direct URI to download it so I ended up downloading it to my machine, uploading to the S3 bucket through the web UI and then pulling it back down again using a 's3cmd get'. #epic In retrospect the https://launchpad.net/ubuntu/+source/s3cmd[s3cmd PPA] might have been a better option. Anyway, when I used this s3cmd it uploaded using multi part fine: [source,bash] ---- ... /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [part 761 of 775, 15MB] 15728640 of 15728640 100% in 3s 4.12 MB/s done /mnt/ebs/myfile.tar -> s3://mybucket.somewhere.com/myfile.tar [part 762 of 775, 15MB] ... ----

s3cmd-put-fails-with-connection-reset-by-peer-for-large-files

https://markhneedham.com/blog/2013/07/30/s3cmd-put-fails-with-connection-reset-by-peer-for-large-files

2013-07-30 06:01:47

netcat: Strange behaviour with UDP - only receives first packet sent

I was playing around with http://nc110.sourceforge.net/[netcat] yesterday to create a client and server which would communicate via UDP packets and I rediscovered some "weird" behaviour which I'd previously encountered but not explained. I started up a netcat server listening for UDP packets on port 9000 of my machine: [source,bash] ---- $ nc -kluv localhost 9000 ---- We can check with lsof what running that command has done: [source,bash] ---- $ lsof -Pni :9000 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 63289 markhneedham 5u IPv6 0xc99222a54b3975b5 0t0 UDP [::1]:9000 ---- We can see that the netcat process is listening on port 9000 so let's send it a UDP packet, using another netcat process: [source,bash] ---- $ echo "mark" | nc -vvu localhost 9000 -4 Connection to localhost 9000 port [udp/cslistener] succeeded! ---- We can see the sending of the UDP packet was successful and it shows up on the netcat server's terminal as well. [source,bash] ---- $ nc -kluv localhost 9000 XXXXmark ---- If we 'Ctrl-C' the netcat client and run it again we'll notice that it's still able to connect to the port but we don't see the message in the netcat server's terminal: [source,bash] ---- $ echo "mike" | nc -vvu localhost 9000 -4 Connection to localhost 9000 port [udp/cslistener] succeeded! ---- [source,bash] ---- $ nc -kluv localhost 9000 XXXXmark ---- I wasn't sure what was going on but eventually came across http://stackoverflow.com/questions/7696862/strange-behavoiur-of-netcat-with-udp[an explanation by David Schwartz]: ____ When nc is listening to a UDP socket, it 'locks on' to the source port and source IP of the first packet it receives. As soon as it received its first datagram (from port 52832), it issued a connect system call 'connecting' it to the 127.0.0.1:52832. For UDP, a connect rejects all packets that don't match the IP and port in the connect. ____ If we use lsof again we can see that we have exactly the same problem: [source,bash] ---- $ lsof -Pni :9000 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 63508 markhneedham 5u IPv6 0xc99222a54b394c5d 0t0 UDP [::1]:9000->[::1]:63732 ---- In our case the netcat server has created a connection between port 9000 and port 63732 and rejects packets coming in from any other IP/port combination. I thought 'Ctrl-C' on the netcat client would kill the connection but it doesn't. At this stage I wasn't sure what to do but https://twitter.com/natbobc[Nathan] pointed out that if I made use of timeouts on the client and server then it would be possible to send multiple UDP packets. I restarted the netcat server but this time with a 1 second timeout: [source,bash] ---- $ nc -kluvw 1 localhost 9000 ---- And then started sending UDP packets from a netcat client also with a 1 second timeout: [source,bash] ---- $ echo -e "all" | nc -vvuw 1 localhost 9000 Connection to localhost 9000 port [udp/cslistener] succeeded! $ echo -e "the" | nc -vvuw 1 localhost 9000 Connection to localhost 9000 port [udp/cslistener] succeeded! $ echo -e "udp" | nc -vvuw 1 localhost 9000 Connection to localhost 9000 port [udp/cslistener] succeeded! $ echo -e "packets" | nc -vvuw 1 localhost 9000 Connection to localhost 9000 port [udp/cslistener] succeeded! ---- And the netcat server now receives all of them: [source,bash] ---- $ nc -kluvw 1 localhost 9000 XXXXall XXXXthe XXXXudp XXXXpackets ---- If we increase the client timeout a bit so that we can run lsof while it's connected we can see that the connection exists for the duration of the timeout: [source,bash] ---- $ lsof -Pni :9000 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 64317 markhneedham 5u IPv6 0xc99222a54b394c5d 0t0 UDP [::1]:9000 nc 64541 markhneedham 5u IPv6 0xc99222a54cc0101d 0t0 UDP [::1]:55792->[::1]:9000 ---- But then once it's finished it goes back to generally listening for UDP packets on that port which is exactly what we want: [source,bash] ---- $ lsof -Pni :9000 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 64317 markhneedham 5u IPv6 0xc99222a54b394c5d 0t0 UDP [::1]:9000 ----

netcat-strange-behaviour-with-udp-only-receives-first-packet-sent

https://markhneedham.com/blog/2013/07/30/netcat-strange-behaviour-with-udp-only-receives-first-packet-sent

2013-07-08 22:14:38

Survivorship Bias and Product Development

A couple of months ago I came across an interesting article by the author of 'http://www.amazon.co.uk/You-are-Not-Smart-Yourself/dp/1851689397/ref=sr_1_1?ie=UTF8&qid=1373320231&sr=8-1&keywords=you+are+not+so+smart[You Are Not So Smart]' about a fallacy known as 'http://youarenotsosmart.com/2013/05/23/survivorship-bias/[Survivorship Bias]' which http://en.wikipedia.org/wiki/Survivorship_bias[Wikipedia] defines as: ____ The logical error of concentrating on the people or things that "survived" some process and inadvertently overlooking those that didn't because of their lack of visibility. ____ I particularly liked the story describing how Abraham Wald helped the US military overcome an instance of this error when trying to work out where to place armour on their bomber planes: ____ The military looked at the bombers that had returned from enemy territory. They recorded where those planes had taken the most damage. Over and over again, they saw the bullet holes tended to accumulate along the wings, around the tail gunner, and down the center of the body. Wings. Body. Tail gunner. Naturally, the commanders wanted to put the thicker protection where they could clearly see the most damage, where the holes clustered. But Wald said no, that would be precisely the wrong decision. Putting the armor there wouldn't improve their chances at all. The mistake, which Wald saw instantly, was that the holes showed where the planes were strongest. The holes showed where a bomber could be shot and still survive the flight home, Wald explained. After all, here they were, holes and all. It was the planes that weren't there that needed extra protection, and they had needed it in places that these planes had not. The holes in the surviving planes actually revealed the locations that needed the least additional armor. *Look at where the survivors are unharmed, he said, and that's where these bombers are most vulnerable*; that's where the planes that didn't make it back were hit. ____ I find the concept interesting on its own but as I'm working at a product company I was trying to understand how applicable it is for my particular context. With respect to a product I think you'd say that non survivors are people who started using your product and then gave at some stage for whatever reason. Those people may not reach out for help so you lose the opportunity to get their feedback about the problems with your product. At the other end of the scale you have people who are very happy with your product (the survivors) and they will often give you feedback about things that they'd like to see in the product for which they may currently have found a work around for. What interests me at the moment is understanding whether the survivors' opinions about how to improve the product are the same as that of the non survivors - survivorship bias suggests this probably isn't the case so we need to find a way to learn what's hurting the non survivors. One way to do this is to conduct http://www.markhneedham.com/blog/2013/01/27/ab-testing-thoughts-so-far/[user testing] where we get potential users of our product to use it and then observe the pain points that they encounter. Although we don't get to see in which areas people would be prepared to persevere to achieve their goal, it is still useful for identifying weak points. Another thing that my colleagues and I have been doing is discussing times at which we felt like giving up while using the product but persevered and ended up being survivors. The reason looking at this is interesting is that we tend to be affected by http://www.markhneedham.com/blog/2013/06/06/the-affect-heuristic/[the affect heuristic] and although we might be prepared to overlook a weakness of the product others might go elsewhere. I'm sure there is more to this than what I've thought about so far so if you have any cool insights please share them in the comments.

survivorship-bias-and-product-development

https://markhneedham.com/blog/2013/07/08/survivorship-bias-and-product-development

2013-07-08 23:19:32

JAX RS: Streaming a Response using StreamingOutput

A couple of weeks ago https://twitter.com/jimwebber[Jim] and I were building out a http://docs.neo4j.org/chunked/milestone/server-unmanaged-extensions.html[neo4j unmanaged extension] from which we wanted to return the results of a traversal which had a lot of paths. Our code initially looked a bit like this: [source,java] ---- package com.markandjim @Path("/subgraph") public class ExtractSubGraphResource { private final GraphDatabaseService database; public ExtractSubGraphResource(@Context GraphDatabaseService database) { this.database = database; } @GET @Produces(MediaType.TEXT_PLAIN) @Path("/{nodeId}/{depth}") public Response hello(@PathParam("nodeId") long nodeId, @PathParam("depth") int depth) { Node node = database.getNodeById(nodeId); final Traverser paths = Traversal.description() .depthFirst() .relationships(DynamicRelationshipType.withName("whatever")) .evaluator( Evaluators.toDepth(depth) ) .traverse(node); StringBuilder allThePaths = new StringBuilder(); for (org.neo4j.graphdb.Path path : paths) { allThePaths.append(path.toString() + "\n"); } return Response.ok(allThePaths.toString()).build(); } } ---- We then compiled that into a JAR, placed it in 'plugins' and added the following line to 'conf/neo4j-server.properties': [source,text] ---- org.neo4j.server.thirdparty_jaxrs_classes=com.markandjim=/unmanaged ---- After we'd restarted the neo4j server we were able to call this end point using cURL like so: [source,text] ---- $ curl -v http://localhost:7474/unmanaged/subgraph/1000/10 ---- This approach works quite well but Jim pointed out that it was quite inefficient to load all those paths up into memory, something which http://blog.neo4j.org/2012/04/streaming-rest-api-interview-with.html[Michael has written about previously with respect to the the streaming REST API.] We thought it would be quite cool if we could stream it as we got to each path. Traverser wraps an iterator so we are lazily evaluating the result set in any case. After a bit of searching we came http://stackoverflow.com/questions/12012724/jersey-example-of-using-streamingoutput-as-response-entity[StreamingOutput] which is exactly what we need. We adapted our code to use that instead: [source,java] ---- package com.markandjim @Path("/subgraph") public class ExtractSubGraphResource { private final GraphDatabaseService database; public ExtractSubGraphResource(@Context GraphDatabaseService database) { this.database = database; } @GET @Produces(MediaType.TEXT_PLAIN) @Path("/{nodeId}/{depth}") public Response hello(@PathParam("nodeId") long nodeId, @PathParam("depth") int depth) { Node node = database.getNodeById(nodeId); final Traverser paths = Traversal.description() .depthFirst() .relationships(DynamicRelationshipType.withName("whatever")) .evaluator( Evaluators.toDepth(depth) ) .traverse(node); StreamingOutput stream = new StreamingOutput() { @Override public void write(OutputStream os) throws IOException, WebApplicationException { Writer writer = new BufferedWriter(new OutputStreamWriter(os)); for (org.neo4j.graphdb.Path path : paths) { writer.write(path.toString() + "\n"); } writer.flush(); } }; return Response.ok(stream).build(); } ---- As far as I can tell the only discernible difference between the two approaches is that you get an almost immediate response from the streamed approached whereas the first approach has to put everything in the StringBuilder first. Both approaches make use of http://en.wikipedia.org/wiki/Chunked_transfer_encoding[chunked transfer encoding] which according to tcpdump seems to have a maximum packet size of 16332 bytes: [source,bash] ---- 00:10:27.361521 IP localhost.7474 > localhost.55473: Flags [.], seq 6098196:6114528, ack 179, win 9175, options [nop,nop,TS val 784819663 ecr 784819662], length 16332 00:10:27.362278 IP localhost.7474 > localhost.55473: Flags [.], seq 6147374:6163706, ack 179, win 9175, options [nop,nop,TS val 784819663 ecr 784819663], length 16332 ----

jax-rs-streaming-a-response-using-streamingoutput

https://markhneedham.com/blog/2013/07/08/jax-rs-streaming-a-response-using-streamingoutput

2013-07-08 23:48:23

neo4j Unmanaged Extension: Creating gzipped streamed responses with Jetty

I recently wrote a blog post describing how we http://www.markhneedham.com/blog/2013/07/08/jax-rs-streaming-a-response-using-streamingoutput/[created a streamed response] and the next thing we wanted to do was gzip the response to shrink it's size a bit. A bit of searching led to http://stackoverflow.com/questions/7546783/uncompress-gzip-http-response-using-jersey-client-api-java[GZIPContentEncodingFilter popping up a lot of times] but this is actually needed for a client processing a gripped response rather than helping us to gzip a response from the server. I noticed that there was https://groups.google.com/forum/#!topic/neo4j/D_2HcLufDTw[a question about this on the mailing list from about a year ago] although https://twitter.com/mesirii[Michael] pointed out that the repository has now moved and https://github.com/neo4j-contrib/authentication-extension/blob/1.9/src/main/java/org/neo4j/server/extension/auth/AuthenticationExtensionInitializer.java#L84[the example is available here] instead. I adapted the example a bit and ended up with the following lifecycle plugin: [source,java] ---- package com.markandjim; public class GZipInitialiser implements SPIPluginLifecycle { private WebServer webServer; @Override public Collection<Injectable<?>> start(NeoServer neoServer) { webServer = getWebServer(neoServer); GzipFilter filter = new GzipFilter(); webServer.addFilter(filter, "/*"); return Collections.emptyList(); } private WebServer getWebServer(final NeoServer neoServer) { if (neoServer instanceof AbstractNeoServer) { return ((AbstractNeoServer) neoServer).getWebServer(); } throw new IllegalArgumentException("expected AbstractNeoServer"); } @Override public Collection<Injectable<?>> start(GraphDatabaseService graphDatabaseService, Configuration configuration) { throw new IllegalAccessError(); } @Override public void stop() { } } ---- I then added the following line to 'resources/META-INF/services/org.neo4j.server.plugins.PluginLifecycle: [source,text] ---- com.markandjim.GZipInitialiser ---- After compiling that and deploying the JAR to the 'plugins' I tried calling the end point using cURL: [source,text] ---- $ curl -H "Accept-Encoding:gzip,deflate" -v http://localhost:7474/unmanaged/subgraph/1000/1 * About to connect() to localhost port 7474 (#0) * Trying ::1... * Connection refused * Trying 127.0.0.1... * connected * Connected to localhost (127.0.0.1) port 7474 (#0) > GET /unmanaged/subgraph/1000/1 HTTP/1.1 > User-Agent: curl/7.24.0 (x86_64-apple-darwin12.0) libcurl/7.24.0 OpenSSL/0.9.8r zlib/1.2.5 > Host: localhost:7474 > Accept: */* > Accept-Encoding:gzip,deflate > < HTTP/1.1 200 OK < Content-Type: text/plain < Access-Control-Allow-Origin: * < Content-Encoding: gzip < Transfer-Encoding: chunked < Server: Jetty(6.1.25) --- gibberish! ---- The GZIPContentEncodingFilter that I mentioned earlier comes in handy if we want to call the end point from a Jersey client: [source,java] ---- public class Neo4jJerseyClient { public static void main(String[] args) { Client client = Client.create(); client.addFilter(new GZIPContentEncodingFilter(false)); WebResource webResource = client.resource("http://localhost:7474/unmanaged/subgraph/1000/1"); ClientResponse response = webResource.header("accept-encoding", "gzip,deflate").get(ClientResponse.class); System.out.println("response = " + response.getEntity(String.class)); } } ---- We could also call it using HTTParty from the land of Ruby: [source,ruby] ---- response = HTTParty.get("http://localhost:7474/unmanaged/subgraph/1000/1", :headers => { 'Accept-Encoding' => 'gzip,deflate' } ) p response ----

neo4j-unmanaged-extension-creating-gzipped-streamed-responses-with-jetty

https://markhneedham.com/blog/2013/07/08/neo4j-unmanaged-extension-creating-gzipped-streamed-responses-with-jetty

2013-07-13 18:47:49

Git/GitHub: Squashing all commits before sending a pull request

My colleague https://twitter.com/mesirii[Michael] has been doing some work to make it easier for people to http://www.neo4j.org/develop/import[import data into neo4j] and his latest attempt is https://github.com/jexp/neo4j-shell-tools[neo4j-shell-tools] which adds some additional commands to the http://docs.neo4j.org/chunked/stable/shell.html[neo4j-shell]. I've spent a bit of time refactoring the https://github.com/jexp/neo4j-shell-tools/blob/master/readme.md[readme] which I'd done on https://github.com/mneedham/neo4j-shell-tools/commits/readme[a branch of my fork of the repository] and consisted of 46 commits, most changing 2 or 3 lines. I wanted to send Michael a pull request on Github but first I needed to squash all my commits down into a single one. I initially thought there might be a way that I could do that via Github but I couldn't see how to do that and eventually came across http://blog.steveklabnik.com/posts/2012-11-08-how-to-squash-commits-in-a-github-pull-request[a post on Steve Klabnik's blog] which explained what I needed to do. This is what my .git/config looked like initially: [source,bash] ---- [remote "origin"] fetch = +refs/heads/*:refs/remotes/origin/* url = git@github.com:mneedham/neo4j-shell-tools.git [branch "master"] remote = origin merge = refs/heads/master [remote "base"] url = git@github.com:jexp/neo4j-shell-tools.git fetch = +refs/heads/*:refs/remotes/base/* [branch "readme"] remote = origin merge = refs/heads/readme ---- I had all my commits on the 'readme' branch but the easiest approach seemed to be to create another branch on which I could squash all my commit - I called that branch 'readme-pull': [source,bash] ---- $ git branch readme-pull $ git checkout readme-pull Switched to branch 'readme-pull' ---- I then synced myself with Michael's repository: [source,bash] ---- $ git fetch base remote: Counting objects: 77, done. remote: Compressing objects: 100% (18/18), done. remote: Total 43 (delta 15), reused 40 (delta 12) Unpacking objects: 100% (43/43), done. From github.com:jexp/neo4j-shell-tools e81c431..c4e94f6 master -> base/master $ git rebase base/master First, rewinding head to replay your work on top of it... ---- I then had to handle any conflicts when applying my changes on top of Michael's master repository and then I was in a position to squash all my commits! We can use rebase in interactive mode to do this and I've always done so by counting back how many commits I want to squash, so in this case it was 35: ~~~bash $ git rebase -i HEAD~35 pick 141d0ae updating readme with link pick 94f8f93 more updating pick 03de50b readme updates pick 4e60332 more updates pick 3447d50 simplifying pick d577520 tweaks pick 2d993d4 more pick f948582 list of commands pick 713aae8 updating ~~~ I later realised that I could have just passed in the last commit hash from the master to the rebase command i.e. ~~~bash commit c4e94f668223d53f6c7364d19aa965d09ea7eb00 Author: Michael Hunger <github@jexp.de> Date: Fri Jul 12 10:33:55 2013 +0200 fixed test ~~~ ~~~bash $ git rebase -i c4e94f668223d53f6c7364d19aa965d09ea7eb00 ~~~ I then set all but the first commit to 'http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages[squash]' and pushed to my repository: ~~~bash $ git push -u origin readme-pull:readme-pull ~~~ Finally I issued https://github.com/jexp/neo4j-shell-tools/pull/12[my pull request] and Michael merged it in!

gitgithub-squashing-all-commits-before-sending-a-pull-request

https://markhneedham.com/blog/2013/07/13/gitgithub-squashing-all-commits-before-sending-a-pull-request

2013-07-14 14:31:44

Java: Testing a socket is listening on all network interfaces/wildcard interface

I previously wrote http://www.markhneedham.com/blog/2013/07/14/learning-more-about-network-sockets/[a blog post describing how I've been trying to learn more about network sockets] in which I created some server sockets and connected to them using http://nc110.sourceforge.net/[netcat]. The next step was to do the same thing in Java and I started out by writing a server socket which echoed any messages sent by the client: [source,java] ---- public class EchoServer { public static void main(String[] args) throws IOException { int port = 4444; ServerSocket serverSocket = new ServerSocket(port, 50, InetAddress.getByAddress(new byte[] {0x7f,0x00,0x00,0x01})); System.err.println("Started server on port " + port); while (true) { Socket clientSocket = serverSocket.accept(); System.err.println("Accepted connection from client: " + clientSocket.getRemoteSocketAddress() ); In in = new In (clientSocket); Out out = new Out(clientSocket); String s; while ((s = in.readLine()) != null) { out.println(s); } System.err.println("Closing connection with client: " + clientSocket.getInetAddress()); out.close(); in.close(); clientSocket.close(); } } } public final class In { private Scanner scanner; public In(java.net.Socket socket) { try { InputStream is = socket.getInputStream(); scanner = new Scanner(new BufferedInputStream(is), "UTF-8"); } catch (IOException ioe) { System.err.println("Could not open " + socket); } } public String readLine() { String line; try { line = scanner.nextLine(); } catch (Exception e) { line = null; } return line; } public void close() { scanner.close(); } } public class Out { private PrintWriter out; public Out(Socket socket) { try { out = new PrintWriter(socket.getOutputStream(), true); } catch (IOException ioe) { ioe.printStackTrace(); } } public void close() { out.close(); } public void println(Object x) { out.println(x); out.flush(); } } ---- I ran the main method of the class and this creates a server socket on port 4444 listening on the 127.0.0.1 interface and we can connect to it using netcat like so: [source,bash] ---- $ nc -v 127.0.0.1 4444 Connection to 127.0.0.1 4444 port [tcp/krb524] succeeded! hello hello ---- The output in my IntelliJ console looked like this: [source,text] ---- Started server on port 4444 Accepted connection from client: /127.0.0.1:63222 Closing connection with client: /127.0.0.1 ---- Using netcat is fine but what I actually wanted to do was write some test code which would check that I'd made sure the server socket on port 4444 was accessible via all interfaces i.e. bound to 0.0.0.0. There are actually some http://docs.oracle.com/javase/tutorial/networking/nifs/retrieving.html[quite nice classes in Java] which make this very easy to do and wiring those together I ended up with the following client code: [source,java] ---- public class EchoClient { public static void main(String[] args) throws IOException { Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces(); for (NetworkInterface networkInterface : Collections.list(nets)) { for (InetAddress inetAddress : Collections.list(networkInterface.getInetAddresses())) { Socket socket = null; try { socket = new Socket(inetAddress, 4444); System.out.println(String.format("Connected using %s [%s]", networkInterface.getDisplayName(), inetAddress)); } catch (ConnectException ex) { System.out.println(String.format("Failed to connect using %s [%s]", networkInterface.getDisplayName(), inetAddress)); } finally { if (socket != null) { socket.close(); } } } } } } ---- If we run the main method of that class we'll see the following output (on my machine at least!): [source,text] ---- Failed to connect using en0 [/fe80:0:0:0:9afe:94ff:fe4f:ee50%4] Failed to connect using en0 [/192.168.1.89] Failed to connect using lo0 [/0:0:0:0:0:0:0:1] Failed to connect using lo0 [/fe80:0:0:0:0:0:0:1%1] Connected using lo0 [/127.0.0.1] ---- Interestingly we can't even connect via the loopback interface using IPv6 which is perhaps not that surprising in retrospect given we bound using an IPv4 address. If we tweak the second line of EchoServer from: [source,java] ---- ServerSocket serverSocket = new ServerSocket(port, 50, InetAddress.getByAddress(new byte[] {0x7f,0x00,0x00,0x01})); ---- to: [source,java] ---- ServerSocket serverSocket = new ServerSocket(port, 50, InetAddress.getByAddress(new byte[] {0x00,0x00,0x00,0x00})); ---- And restart the server before re-running the client we can now connect through all interfaces: [source,text] ---- Connected using en0 [/fe80:0:0:0:9afe:94ff:fe4f:ee50%4] Connected using en0 [/192.168.1.89] Connected using lo0 [/0:0:0:0:0:0:0:1] Connected using lo0 [/fe80:0:0:0:0:0:0:1%1] Connected using lo0 [/127.0.0.1] ---- We can then wrap the EchoClient code into our testing framework to assert that we can connect via all the interfaces.

java-testing-a-socket-is-listening-on-all-network-interfaceswildcard-interface

https://markhneedham.com/blog/2013/07/14/java-testing-a-socket-is-listening-on-all-network-interfaceswildcard-interface

2013-07-14 09:52:17

Learning more about network sockets

While reading through some of the https://github.com/neo4j/neo4j[neo4j code] a few weeks ago I realised that I didn't have a very good understanding about the mechanics behind network ports/sockets so I thought I'd try to learn more. In particular I'd not considered what binding a socket to different network interfaces meant so I decided to setup a few examples using netcat to help me understand better. To start with let's list the network interfaces that I have on my machine using ifconfig: [source,bash] ---- $ ifconfig -u lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384 options=3<RXCSUM,TXCSUM> inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 inet 127.0.0.1 netmask 0xff000000 inet6 ::1 prefixlen 128 en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500 ether xxxxxxxxxxxx inet6 fe80::9afe:94ff:fe4f:ee50%en0 prefixlen 64 scopeid 0x4 inet 192.168.1.89 netmask 0xffffff00 broadcast 192.168.1.255 media: autoselect status: active p2p0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 2304 ether xxxxxxxxxxxx media: autoselect status: inactive ---- 'p2p0' isn't active so we'll only be able to use the other two to make a socket connection on the machine. We'll use netcat to setup a server socket on port 4444 listening on the loopback interface: [source,bash] ---- $ nc -l -k 127.0.0.1 4444 ---- We can use lsof to see how this has been setup: [source,bash] ---- $ lsof -Pni :4444 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME java 34178 markhneedham 35u IPv6 0x114b98295506482d 0t0 TCP 127.0.0.1:4444 (LISTEN) ---- Let's try and connect to that port using netcat: [source,bash] ---- $ nc -v 127.0.0.1 4444 Connection to 127.0.0.1 4444 port [tcp/krb524] succeeded! ---- That works as we'd expect but if we try to connect using the IP of the 'en0' interface we'll get an error: [source,bash] ---- $ nc -v 192.168.1.89 4444 nc: connect to 192.168.1.89 port 4444 (tcp) failed: Connection refused ---- However, if we setup netcat to listen on the wildcard interface (0.0.0.0) then we would be able to connect to 4444 regardless of the interface: [source,bash] ---- $ nc -l -k 0.0.0.0 4444 ---- [source,bash] ---- $ nc -v 192.168.1.89 4444 Connection to 192.168.1.89 4444 port [tcp/krb524] succeeded! $ nc -v 127.0.0.1 4444 Connection to 127.0.0.1 4444 port [tcp/krb524] succeeded! ---- If we check lsof it will confirm that we are listening on 4444 on all interfaces:</p ~~~bash $ lsof -Pni :4444 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 37725 markhneedham 3u IPv4 0x114b98294ba8dfd5 0t0 TCP *:4444 (LISTEN) ~~~ One thing I hadn't realised is that you can set up two different processes listening on the same port but on different interfaces. e.g. ~~~bash $ nc -l -k 127.0.0.1 4444 $ nc -l -k 0.0.0.0 4444 ~~~ We can see from lsof how this has been setup: ~~~bash $ lsof -Pni :4444 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME nc 38306 markhneedham 3u IPv4 0x114b98294ba8dfd5 0t0 TCP *:4444 (LISTEN) nc 38331 markhneedham 3u IPv4 0x114b98294cc53fd5 0t0 TCP 127.0.0.1:4444 (LISTEN) ~~~ If we make a socket connection to 127.0.0.1 it goes to our first netcat and if we use 192.168.1.89 the second one is used. Finally, if we try to bind a server socket on an interface that we don't own netcat will fail in a fairly predictable way: ~~~bash $ nc -l -k 192.168.1.90 4444 nc: Can't assign requested address ~~~

learning-more-about-network-sockets

https://markhneedham.com/blog/2013/07/14/learning-more-about-network-sockets

2013-07-22 22:37:28

Lessons from supporting production code

Until I started working on the http://www.uswitch.com/[uSwitch] energy website around 8 months ago I had not really done any support of a production system so I learnt some interesting lessons in my time there. == Look at the new code first We had our application wired up to http://airbrakeapp.com/pages/home[Airbrake] so whenever a user did anything which resulted in an exception being thrown we received a report with the stack trace, environment variables and which page they were on. When trying to work out what had happened I initially started from scratch and tried to work backwards from the source and create a scenario in my head of what they might have done to get that error. After a few times of doing this it became clear that there was a reasonable chance that if a user was experiencing a problem it was probably because of some new code that we'd just introduced. We therefore tweaked our bug hunting algorithm to initially check code that had been changed recently and only after ruling that out did we work back from first principles. == It may never have worked Sometimes it became clear that new code wasn't to blame but it seemed implausible that the error could have actually happened. There was a tendency to assume that the user must be deliberately doing something to make the application break but it soon became clear that they had just managed to hit a code path that had not been hit before. Even if you've done extensive testing on a system users still seem to find paths through the code that haven't failed previously so it seems best to just assume that is going to happen at some stage. == Log all the things As I mentioned earlier we were using a 3rd party service to collect errors and other helpful information which was really useful for helping us find the root cause of problems. The type of logging that you need varies so for a product like http://www.neo4j.org/[neo4j] as well as logging exceptions we also log system information and memory settings. Obviously I'm quite new to this type of work so I'm sure others will have useful bits of advice to share as well.

lessons-from-supporting-production-code

https://markhneedham.com/blog/2013/07/22/lessons-from-supporting-production-code

2013-07-22 23:47:28

On "The fear of blogging about technical topics"

My former colleague https://twitter.com/annejsimmons[Anne Simmons] recently wrote an interesting post in which she describes http://annejsimmons.com/2013/07/16/the-fear-of-blogging-about-technical-topics/[some of the reasons that she finds herself not wanting to write about technical topics.]. I wrote a post at the end of 2012 in which I explained some of the reasons why I think http://www.markhneedham.com/blog/2013/01/05/a-new-years-idea-share-what-you-learn/[writing about what you learn is a good idea] but Anne brought up some things I hadn't thought of which I think are worth addressing. She's already described her own mantras to overcome these but I thought it'd still be interesting to share my experience as well: == What do I know that the internet doesn't already?! I've found that then posts I write in which I aggregate a bunch of information that I found from different places tend to be my most read posts. A lot of the people that I've worked with (including me) when encountered with a stack trace will paste it straight into google to try and solve their problem. I've had the same experience as Anne in spending ages trying to solve a problem and thinking it would be cool to save someone else (usually future me) from having to rediscover the solution in the future. == Will people judge me about what knowledge I do have?/What if I'm wrong?! In 5 years of writing I've only had a couple of times when people commented in what I thought was an unnecessary manner but the majority of feedback has been very positive. Frequently people actually teach me something that I didn't know rather than criticising what I do know so for me writing has been a net gain. A strange side effect is that people think I know much more than I do based on writing about things I've been working on. == In summary It can only be a good thing for the internet if more people write about the things that they're working on so I hope Anne keeps to her one post a month target! I'll finish off with the http://www.catb.org/esr/faqs/hacker-howto.html[Eric Raymond] quote that I used on http://www.markhneedham.com/blog/2013/01/05/a-new-years-idea-share-what-you-learn/[my previous post about sharing what you learn]: ____ Creative brains are a valuable, limited resource. They shouldn't be wasted on re-inventing the wheel when there are so many fascinating new problems waiting out there. To behave like a hacker, you have to believe that the thinking time of other hackers is precious -- so much so that *it's almost a moral duty for you to share information, solve problems and then give the solutions away just so other hackers can solve new problems instead of having to perpetually re-address old ones*. ____

on-the-fear-of-blogging-about-technical-topics

https://markhneedham.com/blog/2013/07/22/on-the-fear-of-blogging-about-technical-topics

2013-09-20 21:13:01

Clojure: Converting an array/set into a hash map

When I was http://www.markhneedham.com/blog/2013/08/31/elo-rating-system-ranking-champions-league-teams-using-clojure/[implementing the Elo Rating algorithm] a few weeks ago one thing I needed to do was come up with a base ranking for each team. I started out with a set of teams that looked like this: [source,lisp] ---- (def teams #{ "Man Utd" "Man City" "Arsenal" "Chelsea"}) ---- and I wanted to transform that into a map from the team to their ranking e.g. [source,text] ---- Man Utd -> {:points 1200} Man City -> {:points 1200} Arsenal -> {:points 1200} Chelsea -> {:points 1200} ---- I had read the documentation of +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/array-map[array-map]+++</cite>+++, a function which can be used to transform a collection of pairs into a map, and it seemed like it might do the trick. I started out by building an array of pairs using +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/mapcat[mapcat]+++</cite>+++: [source,lisp] ---- > (mapcat (fn [x] [x {:points 1200}]) teams) ("Chelsea" {:points 1200} "Man City" {:points 1200} "Arsenal" {:points 1200} "Man Utd" {:points 1200}) ---- +++<cite>+++array-map+++</cite>+++ constructs a map from pairs of values e.g. [source,lisp] ---- > (array-map "Chelsea" {:points 1200} "Man City" {:points 1200} "Arsenal" {:points 1200} "Man Utd" {:points 1200}) ("Chelsea" {:points 1200} "Man City" {:points 1200} "Arsenal" {:points 1200} "Man Utd" {:points 1200}) ---- Since we have a collection of pairs rather than individual pairs we need to use the +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/apply[apply]+++</cite>+++ function as well: [source,lisp] ---- > (apply array-map ["Chelsea" {:points 1200} "Man City" {:points 1200} "Arsenal" {:points 1200} "Man Utd" {:points 1200}]) {"Chelsea" {:points 1200}, "Man City" {:points 1200}, "Arsenal" {:points 1200}, "Man Utd" {:points 1200}} ---- And if we put it all together we end up with the following: [source,lisp] ---- > (apply array-map (mapcat (fn [x] [x {:points 1200}]) teams)) {"Man Utd" {:points 1200}, "Man City" {:points 1200}, "Arsenal" {:points 1200}, "Chelsea" {:points 1200}} ---- It works but the function we pass to +++<cite>+++mapcat+++</cite>+++ feels a bit clunky. Since we just need to create a collection of team/ranking pairs we can use the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/vector[vector]+++</cite>+++ and +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/repeat[repeat]+++</cite>+++ functions to build that up instead: [source,lisp] ---- > (mapcat vector teams (repeat {:points 1200})) ("Chelsea" {:points 1200} "Man City" {:points 1200} "Arsenal" {:points 1200} "Man Utd" {:points 1200}) ---- And if we put the +++<cite>+++apply array-map+++</cite>+++ code back in we still get the desired result: [source,lisp] ---- > (apply array-map (mapcat vector teams (repeat {:points 1200}))) {"Chelsea" {:points 1200}, "Man City" {:points 1200}, "Arsenal" {:points 1200}, "Man Utd" {:points 1200}} ---- Alternatively we could use +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/assoc[assoc]+++</cite>+++ like this: [source,lisp] ---- > (apply assoc {} (mapcat vector teams (repeat {:points 1200}))) {"Man Utd" {:points 1200}, "Arsenal" {:points 1200}, "Man City" {:points 1200}, "Chelsea" {:points 1200}} ---- I also came across the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/into[into]+++</cite>+++ function which seemed useful but took in a collection of vectors: [source,lisp] ---- > (into {} [["Chelsea" {:points 1200}] ["Man City" {:points 1200}] ["Arsenal" {:points 1200}] ["Man Utd" {:points 1200}] ]) ---- We therefore need to change the code to use +++<cite>+++map+++</cite>+++ instead of +++<cite>+++mapcat+++</cite>+++: [source,lisp] ---- > (into {} (map vector teams (repeat {:points 1200}))) {"Chelsea" {:points 1200}, "Man City" {:points 1200}, "Arsenal" {:points 1200}, "Man Utd" {:points 1200}} ---- However, my favourite version so far uses the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/zipmap[zipmap]+++</cite>+++ function like so: [source,lisp] ---- > (zipmap teams (repeat {:points 1200})) {"Man Utd" {:points 1200}, "Arsenal" {:points 1200}, "Man City" {:points 1200}, "Chelsea" {:points 1200}} ---- I'm sure there are other ways to do this as well so if you know any let me know in the comments.

clojure-converting-an-arrayset-into-a-hash-map

https://markhneedham.com/blog/2013/09/20/clojure-converting-an-arrayset-into-a-hash-map

2013-09-20 07:00:01

Clojure: Converting a string to a date

I wanted to do some date manipulation in Clojure recently and figured that since https://github.com/seancorfield/clj-time[clj-time] is a wrapper around http://www.joda.org/joda-time/[Joda Time] it'd probably do the trick. The first thing we need to do is add the dependency to our project file and then run +++<cite>+++lein reps+++</cite>+++ to pull down the appropriate JARs. The project file should look something like this: _project.clj_ [source,lisp] ---- (defproject ranking-algorithms "0.1.0-SNAPSHOT" :license {:name "Eclipse Public License" :url "http://www.eclipse.org/legal/epl-v10.html"} :dependencies [[org.clojure/clojure "1.4.0"] [clj-time "0.6.0"]]) ---- Now let's load the clj-time.format namespace into the REPL since we know we'll be parsing dates: [source,lisp] ---- > (require '(clj-time [format :as f])) ---- The string that I want to convert into a date looks like this: [source,lisp] ---- (def string-date "18 September 2012") ---- The first thing we should do is check whether there is an existing formatter that we can use by evaluating the following function: [source,lisp] ---- > (f/show-formatters) ... :hour-minute 06:45 :hour-minute-second 06:45:22 :hour-minute-second-fraction 06:45:22.473 :hour-minute-second-ms 06:45:22.473 :mysql 2013-09-20 06:45:22 :ordinal-date 2013-263 :ordinal-date-time 2013-263T06:45:22.473Z :ordinal-date-time-no-ms 2013-263T06:45:22Z :rfc822 Fri, 20 Sep 2013 06:45:22 +0000 ... ---- There are a lot of different built in formatters but unfortunately I couldn't find one that exactly matched our date format so we'll have to write our own one. For that we'll need to refresh our knowledge of http://docs.oracle.com/javase/1.4.2/docs/api/java/text/SimpleDateFormat.html[Java date formatting]: image::{{<siteurl>}}/uploads/2013/09/2013-09-20_07-48-52.png[2013 09 20 07 48 52,600] We end up with the following formatter: [source,lisp] ---- > (f/parse (f/formatter "dd MMM YYYY") string-date) #<DateTime 2012-09-18T00:00:00.000Z> ---- It took me much longer than it should have to remember that 'MMM' is the pattern to match a short form of a month but it's just the same as what we'd have to do in Java but with some neat wrapper functions.

clojure-converting-a-string-to-a-date

https://markhneedham.com/blog/2013/09/20/clojure-converting-a-string-to-a-date

2013-09-17 01:03:37

Clojure: Merge two maps but only keep the keys of one of them

I've http://www.markhneedham.com/blog/2013/09/17/clojure-updating-keys-in-a-map/[been playing around with Clojure maps] recently and I wanted to merge two maps of rankings where the rankings in the second map overrode those in the first while only keeping the teams from the first map. The +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/merge[merge]+++</cite>+++ function overrides keys in earlier maps but also adds keys that only appear in later maps. For example, if we merge the following maps: [source,lisp] ---- > (merge {"Man. United" 1500 "Man. City" 1400} {"Man. United" 1550 "Arsenal" 1450}) {"Arsenal" 1450, "Man. United" 1550, "Man. City" 1400} ---- we get back all 3 teams but I wanted a function which only returned 'Man. United' and 'Man. City' since those keys appear in the first map and 'Arsenal' doesn't. I http://stackoverflow.com/questions/2753874/how-to-filter-a-persistent-map-in-clojure[wrote the following function]: [source,lisp] ---- (defn merge-rankings [initial-rankings override-rankings] (merge initial-rankings (into {} (filter #(contains? initial-rankings (key %)) override-rankings)))) ---- If we call that we get the desired result: [source,lisp] ---- > (merge-rankings {"Man. United" 1500 "Man. City" 1400} {"Man. United" 1550 "Arsenal" 1450}) {"Man. United" 1550, "Man. City" 1400} ---- An alternative version of that function could use +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/select-keys[select-keys]+++</cite>+++ like so: [source,lisp] ---- (defn merge-rankings [initial-rankings override-rankings] (select-keys (merge initial-rankings override-rankings) (map key initial-rankings))) ---- bitemyapp points out in the comments that we can go even further and use the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/keys[keys]+++</cite>+++ function instead of +++<cite>+++map key+++</cite>+++, like so: [source,lisp] ---- (defn merge-rankings [initial-rankings override-rankings] (select-keys (merge initial-rankings override-rankings) (keys initial-rankings))) ---- Now let's generify the function so it would make sense in the context of any maps, not just ranking related ones: [source,lisp] ---- (defn merge-keep-left [left right] (select-keys (merge left right) (keys left))) ----

clojure-merge-two-maps-but-only-keep-the-keys-of-one-of-them

https://markhneedham.com/blog/2013/09/17/clojure-merge-two-maps-but-only-keep-the-keys-of-one-of-them

2013-09-17 00:24:48

Clojure: Updating keys in a map

I've been playing with Clojure over the last few weeks and as a result I've been using a lot of maps to represent the data. For example if we have the following map of teams to http://www.glicko.net/glicko/glicko.pdf[Glicko] ratings and ratings deviations: [source,lisp] ---- (def teams { "Man. United" {:points 1500 :rd 350} "Man. City" {:points 1450 :rd 300} }) ---- We might want to increase Man. United's points score by one for which we could use the +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/update-in[update-in]+++</cite>+++ function: [source,lisp] ---- > (update-in teams ["Man. United" :points] inc) {"Man. United" {:points 1501, :rd 350}, "Man. City" {:points 1450, :rd 300}} ---- The 2nd argument to +++<cite>+++update-in+++</cite>+++ is a nested associative structure i.e. a sequence of keys into the map in this instance. If we wanted to reset Man. United's points score we could use +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/assoc-in[assoc-in]+++</cite>+++: [source,lisp] ---- > (assoc-in teams ["Man. United" :points] 1) {"Man. United" {:points 1, :rd 350}, "Man. City" {:points 1450, :rd 300}} ---- If we want to update multiple keys at once then we can chain them using the http://clojuredocs.org/clojure_core/clojure.core/-%3E[\->] (thread first) macro: [source,lisp] ---- (-> teams (assoc-in ["Man. United" :points] 1600) (assoc-in ["Man. United" :rd] 200)) {"Man. United" {:points 1600, :rd 200}, "Man. City" {:points 1450, :rd 300}} ---- If instead of replacing just one part of the value we want to replace the whole entry we could use +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/assoc[assoc]+++</cite>+++ instead: [source,lisp] ---- > (assoc teams "Man. United" {:points 1600 :rd 300}) {"Man. United" {:points 1600, :rd 300}, "Man. City" {:points 1450, :rd 300}} ---- +++<cite>+++assoc+++</cite>+++ can also be used to add a new key/value to the map. e.g. [source,lisp] ---- > (assoc teams "Arsenal" {:points 1500 :rd 330}) {"Man. United" {:points 1500, :rd 350}, "Arsenal" {:points 1500, :rd 330}, "Man. City" {:points 1450, :rd 300}} ---- +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/dissoc[dissoc]+++</cite>+++ plays the opposite role and returns a new map without the specified keys: [source,lisp] ---- > (dissoc teams "Man. United" "Man. City") {} ---- And those are all the map based functions I've played around with so far\...

clojure-updating-keys-in-a-map

https://markhneedham.com/blog/2013/09/17/clojure-updating-keys-in-a-map

2013-09-19 23:57:49

Clojure: See every step of a reduce

Last year I wrote about http://www.markhneedham.com/blog/2012/02/25/haskell-viewing-the-steps-of-a-reduce/[a Haskell function called +++<cite>+++scanl+++</cite>+++] which returned the intermediate steps of a fold over a collection and last week I realised that I needed a similar function in Clojure to analyse a reduce I'd written. A simple reduce which adds together the numbers 1-10 would look like this: [source,lisp] ---- > (reduce + 0 (range 1 11)) 55 ---- If we want to see the intermediate values of this function called then instead of using +++<cite>+++http://clojuredocs.org/clojure_core/1.3.0/clojure.core/reduce[reduce]+++</cite>+++ there's a function called +++<cite>+++http://clojuredocs.org/clojure_core/1.3.0/clojure.core/reductions[reductions]+++</cite>+++ which gives us exactly what we want: [source,lisp] ---- > (reductions + 0 (range 1 11)) (0 1 3 6 10 15 21 28 36 45 55) ---- I found this function especially useful when analysing http://www.markhneedham.com/blog/2013/09/14/glicko-rating-system-a-simple-example-using-clojure/[my implementation of the Glicko ranking algorithm] to work out whether a team's ranking was being updated correctly after a round of matches. I initially thought the +++<cite>+++reductions+++</cite>+++ function was only useful as a debugging tool and that you'd always end up changing your code back to use +++<cite>+++reduce+++</cite>+++ after you'd solved the problem but I realise I was mistaken. As part of http://www.markhneedham.com/blog/2013/09/14/glicko-rating-system-a-simple-example-using-clojure/[my implementation of the Glicko algorithm] I wrote a bit of code that applied a reduce across a collection of football seasons and initially just returned the final ranking of each team: [source,lisp] ---- (def initial-team-rankings { "Man Utd" {:points 1200} "Man City" {:points 1300}}) (defn update-team-rankings [teams year] (reduce (fn [ts [team _]] (update-in ts [team :points] inc)) teams teams)) ---- [source,lisp] ---- > (reduce update-team-rankings initial-team-rankings (range 2004 2013)) {"Man City" {:points 1309}, "Man Utd" {:points 1209}} ---- I realised it would actually be quite interesting to see the rankings after each season for which +++<cite>+++reductions+++</cite>+++ comes in quite handy. For example if we want to find the rankings after 3 seasons we could write the following code: [source,lisp] ---- > (nth (reductions update-team-rankings initial-team-rankings (range 2004 2013)) 3) {"Man City" {:points 1303}, "Man Utd" {:points 1203}} ---- Or we could join the result back onto our collection of years and create a map so we can look up the year more easily: [source,lisp] ---- (def final-rankings (zipmap (range 2003 2013) (reductions update-team-rankings initial-team-rankings (range 2004 2013)))) ---- [source,lisp] ---- > (get final-rankings 2006) {"Man City" {:points 1303}, "Man Utd" {:points 1203}} ----

clojure-see-every-step-of-a-reduce

https://markhneedham.com/blog/2013/09/19/clojure-see-every-step-of-a-reduce

2013-09-19 06:55:19

Data Science: Don't build a crawler (if you can avoid it!)

On Tuesday I spoke at the http://www.meetup.com/Data-Science-London/events/139205302/[Data Science London meetup] about http://bit.ly/rankings-dsldn[football data] and I started out by covering some lessons I've learnt about building data sets for personal use when open data isn't available. When that's the case you often end up scraping HTML pages to extract the data that you're interested in and then storing that in files or in a database if you want to be more fancy. Ideally we want to spend our time playing with the data rather than gathering it so we we want to keep this stage to a minimum which we can do by following these rules. == Don't build a crawler One of the most tempting things to do is build a crawler which starts on the home page and then follows some/all the links it comes across, downloading those pages as it goes. This is incredibly time consuming and yet this was the approach I took when scraping an internal staffing application to http://skillsmatter.com/podcast/home/what-do-you-want-to-know[model ThoughtWorks consultants/projects in neo4j] about 18 months ago. https://twitter.com/a5hok[Ashok] wanted to get the same data a few months later and instead of building a crawler, spent a bit of time understanding the URI structure of the pages he wanted and then built up a list of pages to download. It took him in the order of minutes to build a script that would get the data whereas I spent many hours using the crawler based approach. If there is no discernible URI structure or if you want to get every single page then the crawler approach might make sense but I try to avoid it as a first port of call. == Download the files The second thing I learnt is that running http://docs.seleniumhq.org/projects/webdriver/[Web Driver] or http://nokogiri.org/[nokogiri] or https://github.com/cgrand/enlive[enlive] against live web pages and then only storing the parts of the page we're interested in is sub optimal. We pay the network cost every time we run the script and at the beginning of a data gathering exercise we won't know exactly what data we need so we're bound to have to run it multiple times until we get it right. It's much quicker to download the files to disk and work on them locally. == Use wget Having spent a lot of time writing different tools to download the ThoughtWorks data set http://linux.about.com/od/commands/l/blcmdl1_wget.htm[Ashok] asked me why I wasn't using wget instead. I couldn't think of a good reason so now I favour building up a list of URIs and then letting wget take care of downloading them for us. e.g. [source,bash] ---- $ head -n 5 uris.txt https://www.some-made-up-place.com/page1.html https://www.some-made-up-place.com/page2.html https://www.some-made-up-place.com/page3.html https://www.some-made-up-place.com/page4.html https://www.some-made-up-place.com/page5.html $ cat uris.txt | time xargs wget ... Total wall clock time: 3.7s Downloaded: 60 files, 625K in 0.7s (870 KB/s) 3.73 real 0.03 user 0.09 sys ---- If we need to speed things up we can always use the '-P' flag of xargs to do so: [source,bash] ---- cat uris.txt | time xargs -n1 -P10 wget 1.65 real 0.20 user 0.21 sys ---- It pays to be reasonably sensible when using tools like this and of course read the terms and conditions of the site to check what they have to say about downloading copies of pages for personal use. Given that you can get the pages using a web browser anyway it's generally fine but it makes sense not to bombard their site with requests for every single page and instead just focus on the data you're interested in.

data-science-dont-build-a-crawler-if-you-can-avoid-it

https://markhneedham.com/blog/2013/09/19/data-science-dont-build-a-crawler-if-you-can-avoid-it

2013-09-26 07:47:34

Clojure: Writing JSON to a file/reading JSON from a file

A few weeks ago I described how I'd http://www.markhneedham.com/blog/2013/08/26/clojureenlive-screen-scraping-a-html-file-from-disk/[scraped football matches using Clojure's Enlive], and the next step after translating the HTML representation into a Clojure map was to save it as a JSON document. I decided to follow a two step process to achieve this: * Convert hash to JSON string * Write JSON string to file I imagine there's probably a way to convert the hash to a stream and pipe that into a file but my JSON document isn't very large so I think this way is ok for now. +++<cite>+++https://github.com/clojure/data.json[data.json]+++</cite>+++ seems to be the way to go to convert a Hash to a JSON string and I had the following code: [source,lisp] ---- > (require '[clojure.data.json :as json]) nil > (json/write-str { :key1 "val1" :key2 "val2" }) "{\"key2\":\"val2\",\"key1\":\"val1\"}" ---- The next step was to write that into a file and http://stackoverflow.com/questions/7756909/in-clojure-1-3-how-to-read-and-write-a-file[this StackOverflow post describes a couple of ways that we can do this]: [source,lisp] ---- > (use 'clojure.java.io) > (with-open [wrtr (writer "/tmp/test.json")] (.write wrtr (json/write-str {:key1 "val1" :key2 "val2"}))) ---- or [source,lisp] ---- > (spit "/tmp/test.json" (json/write-str {:key1 "val1" :key2 "val2"})) ---- Now I wanted to read the file back into a hash and I started with the following: [source,lisp] ---- > (json/read-str (slurp "/tmp/test.json")) {"key2" "val2", "key1" "val1"} ---- That's not bad but I wanted the keys to be what I know as symbols (e.g. ':key1') from Ruby land. I re-learnt that this is called a keyword in Clojure. Since I'm not very good at reading the documentation I wrote a function to convert all the keys in a map from strings to keywords: [source,lisp] ---- > (defn string-keys-to-symbols [map] (reduce #(assoc %1 (-> (key %2) keyword) (val %2)) {} map)) > (string-keys-to-symbols (json/read-str (slurp "/tmp/test.json"))) {:key1 "val1", :key2 "val2"} ---- What I should have done is pass the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/keyword[keyword]+++</cite>+++ function as an argument to +++<cite>+++read-str+++</cite>+++ instead: [source,lisp] ---- > (json/read-str (slurp "/tmp/test.json") :key-fn keyword) {:key2 "val2", :key1 "val1"} ---- Simple!

clojure-writing-json-to-a-filereading-json-from-a-file

https://markhneedham.com/blog/2013/09/26/clojure-writing-json-to-a-filereading-json-from-a-file

2013-09-26 19:11:29

Clojure: Writing JSON to a file - "Exception Don't know how to write JSON of class org.joda.time.DateTime"

As I mentioned in an earlier post I've been transforming http://www.markhneedham.com/blog/2013/09/26/clojure-writing-json-to-a-filereading-json-from-a-file/[Clojure hash's into JSON strings] using https://github.com/clojure/data.json[data.json] but ran into trouble while trying to parse a hash which contained a http://www.joda.org/joda-time/[Joda Time] DateTime instance. The date in question was constructed like this: [source,lisp] ---- (ns json-date-example (:require [clj-time.format :as f]) (:require [clojure.data.json :as json])) (defn as-date [date-field] (f/parse (f/formatter "dd MMM YYYY") date-field )) (def my-date (as-date "18 Mar 2012")) ---- And when I tried to convert a hash containing that object into a string I got the following exception: [source,lisp] ---- > (json/write-str {:date my-date)}) java.lang.Exception: Don't know how to write JSON of class org.joda.time.DateTime at clojure.data.json$write_generic.invoke (json.clj:367) clojure.data.json$eval2818$fn__2819$G__2809__2826.invoke (json.clj:284) clojure.data.json$write_object.invoke (json.clj:333) clojure.data.json$eval2818$fn__2819$G__2809__2826.invoke (json.clj:284) clojure.data.json$write.doInvoke (json.clj:450) clojure.lang.RestFn.invoke (RestFn.java:425) ---- Luckily it's quite easy to get around this by passing a function to +++<cite>+++write-str+++</cite>+++ that converts the DateTime into a string representation before writing that part of the hash to a string. The function looks like this: [source,lisp] ---- (defn as-date-string [date] (f/unparse (f/formatter "dd MMM YYYY") date)) (defn date-aware-value-writer [key value] (if (= key :date) (as-date-string value) value)) ---- And we make use of the writer like so: [source,lisp] ---- > (json/write-str {:date my-date} :value-fn date-aware-value-writer) "{\"date\":\"18 Mar 2012\"}" ---- If we want to read that string back again and reify our date we create a reader function which converts a string into a DateTime. The +++<cite>+++as-date+++</cite>+++ function from the beginning of this post does exactly what we want so we'll use that: [source,lisp] ---- (defn date-aware-value-reader [key value] (if (= key :date) (as-date value) value)) ---- We can then pass the reader as an argument to +++<cite>+++read-str+++</cite>+++: [source,lisp] ---- > (json/read-str "{\"date\":\"18 Mar 2012\"}" :value-fn date-aware-value-reader :key-fn keyword) {:date #<DateTime 2012-03-18T00:00:00.000Z>} ----

clojure-writing-json-to-a-file-exception-dont-know-how-to-write-json-of-class-org-joda-time-datetime

https://markhneedham.com/blog/2013/09/26/clojure-writing-json-to-a-file-exception-dont-know-how-to-write-json-of-class-org-joda-time-datetime

2013-09-30 22:48:13

On Writing Well - William Zinsser: Book Review

I first came across William Zinsser's 'http://www.amazon.co.uk/On-Writing-Well-Classic-Nonfiction/dp/0060891548/ref=sr_1_1?ie=UTF8&qid=1380578447&sr=8-1&keywords=on+writing+well[On Writing Well]' about a year ago, but put it down having flicked through a couple of the chapters that I felt were relevant. It came back onto my radar a month ago and this time I decided to read it cover to cover as I was sure there were some insights that I'd missed due to my haphazard approach the first time around. What stood out in my memory from my first reading of the book was the emphasis on how *words like a bit, a little, kind of, quite, pretty much and too dilute our sentences* and I've been trying to avoid them in my writing ever since. Other things that stood out for me this time were: * *Avoid unnecessary words* e.g. blared loudly or grinned widely. It's difficult to blare in any other way and if you're grinning it implied that your mouth is open widely. * *Delete troublesome phrases*. If you're having trouble working out the structure for a sentence, it might be beneficial to get rid of it and see if the rest of the paragraph still makes sense. Often it will. * *Rewriting*. The author emphasises over and over again the importance of rewriting a piece of text until you're happy with it. This consists mostly of reshaping and tightening previous drafts. The way it's described sounds very similar to code refactoring. My colleague https://twitter.com/iansrobinson[Ian Robinson] recommended 'http://www.amazon.co.uk/Revising-Prose-Richard-Lanham/dp/0023674407/ref=sr_1_1?ie=UTF8&qid=1380579666&sr=8-1&keywords=Revising+Prose[Revising Prose]' as a useful book to read next in this area. * *Assume the reader knows nothing*. The advice in the chapter on science and technology was probably the most applicable for the type of writing I do and I thought this section was particularly apt: + ____ Describing how a process works is valuable for two reasons. It forces you to make sure that you know how it works. Then it forces you to take the reader through the same sequence of ideas and deductions that made the process clear to you. ____ + I've found this to be the case multiple times although you can achieve the same benefits by presenting a talk on a topic; the benefits aren't unique to writing. * *Explain your judgements*. Don't say something is interesting. Instead explain what makes it interesting and let the reader decide whether or not it deserves that label. * *Use simple words, be specific, be human and use active verbs*. I often fall into the trap of using passive verbs which makes it difficult for the reader to know which part of the sentence they apply to. We want to minimise the amount of translation the reader has to do to understand our writing. * *Use a paragraph as a logical unit*. I remember learning this at secondary school but I've drifted towards a style of writing that treats the sentence as a logical block. My intuition tells me that people find it easier to read text when it's in smaller chunks but I will experiment with grouping my ideas together in paragraphs where that seems sensible. I gleaned these insights mostly from the first half of the book. The second half focused on different forms of writing and showed how to apply the lessons from earlier in the book. Although not all the forms were applicable to me I still found it interesting to read as the author has a nice way with words and you want to keep reading the next sentence. My main concern having read the book is ensuring that *I don't paralyse my ability to finish blog posts* by rewriting ad infinitum.

on-writing-well-william-zinsser-book-review

https://markhneedham.com/blog/2013/09/30/on-writing-well-william-zinsser-book-review

2013-09-30 21:34:01

neo4j/cypher: Translating 1.9 FILTER queries to use 2.0 list comprehensions

I was looking back over some cypher queries I'd written earlier in the year against my football data set to find some examples of where http://docs.neo4j.org/chunked/milestone/syntax-collections.html#_list_comprehension[list comprehensions] could be useful and I came across this query which is used to work out which teams were the most badly behaved in terms of accumulating red and yellow cards: [source,cypher] ---- START team = node:teams('name:*') MATCH team<-[:for]-like_this<-[:started|as_sub]-player-[r?:sent_off_in|booked_in]->game<-[:in]-like_this WITH team, COLLECT(r) AS cards WITH team, FILTER(x IN cards: TYPE(x) = "sent_off_in") AS reds, FILTER(x IN cards: TYPE(x) = "booked_in") AS yellows RETURN team.name, LENGTH(reds) AS redCards, LENGTH(yellows) AS yellowCards ORDER BY (yellowCards*1 + redCards*3) DESC ---- We start by getting all the teams, work out which players played in that game, then work out who got booked or sent off before separating the yellow/red cards into their own respective collections. Finally we assign 3 points for a red card and 1 point for a yellow card and order the teams based on that. [source,bash] ---- ==> +-------------------------------------------------+ ==> | team.name | redCards | yellowCards | ==> +-------------------------------------------------+ ==> | "Stoke City" | 4 | 81 | ==> | "Newcastle United" | 4 | 74 | ==> | "Aston Villa" | 3 | 74 | ==> | "West Ham United" | 1 | 74 | ==> | "West Bromwich Albion" | 4 | 63 | ==> | "Sunderland" | 3 | 63 | ==> | "Wigan Athletic" | 2 | 66 | ==> | "Manchester City" | 3 | 62 | ==> | "Everton" | 3 | 62 | ==> | "Queens Park Rangers" | 3 | 60 | ==> | "Swansea City" | 2 | 59 | ==> | "Norwich City" | 1 | 60 | ==> | "Chelsea" | 3 | 53 | ==> | "Liverpool" | 2 | 54 | ==> | "Manchester United" | 1 | 57 | ==> | "Tottenham Hotspur" | 2 | 54 | ==> | "Arsenal" | 5 | 44 | ==> | "Fulham" | 3 | 48 | ==> | "Southampton" | 2 | 44 | ==> | "Reading" | 1 | 45 | ==> +-------------------------------------------------+ ==> 20 rows ---- Unfortunately if we run that query on a 2.0.0-M05 neo4j database we'll get the following error: [source,bash] ---- ==> SyntaxException: Invalid input '(': expected an identifier character, whitespace, NodeLabel, '.', '[', node labels, "=~", IN, IS, '*', '/', '%', '^', '+', '-', '<', '>', "<=", ">=", '=', "<>", "!=", AND, XOR, OR, WHERE, ')' or ',' (line 1, column 207) ==> "START team = node:teams('name:*') MATCH team<-[:for]-like_this<-[:started|as_sub]-player-[r?:sent_off_in|booked_in]->game<-[:in]-like_this WITH team, COLLECT(r) AS cards WITH team, FILTER(x IN cards: TYPE(x) = "sent_off_in") AS reds, FILTER(x IN cards: TYPE(x) = "booked_in") AS yellows RETURN team.name, LENGTH(reds) AS redCards, LENGTH(yellows) AS yellowCards ORDER BY (yellowCards*1 + redCards*3) DESC" ==> ---- The syntax when using the +++<cite>+++FILTER+++</cite>+++ function has changed a bit so we need to use a +++<cite>+++WHERE+++</cite>+++ clause rather than a ':': [source,cypher] ---- START team = node:teams('name:*') MATCH team<-[:for]-like_this<-[:started|as_sub]-player-[r?:sent_off_in|booked_in]->game<-[:in]-like_this WITH team, COLLECT(r) AS cards WITH team, FILTER(x IN cards WHERE TYPE(x) = "sent_off_in") AS reds, FILTER(x IN cards WHERE TYPE(x) = "booked_in") AS yellows RETURN team.name, LENGTH(reds) AS redCards, LENGTH(yellows) AS yellowCards ORDER BY (yellowCards*1 + redCards*3) DESC ---- However, as I hinted at the beginning of this post, we can also translate the query to make use of the new for comprehensions. I ended up with the following: [source,cypher] ---- START team = node:teams('name:*') MATCH team<-[:for]-like_this<-[:started|as_sub]-player-[r?:sent_off_in|booked_in]->game<-[:in]-like_this WITH team, COLLECT(r) AS cards WITH team, [card IN cards WHERE TYPE(card) = "sent_off_in"] as reds, [card in cards WHERE TYPE(card) = "booked_in"] as yellows RETURN team.name, LENGTH(reds) AS redCards, LENGTH(yellows) AS yellowCards ORDER BY (yellowCards*1 + redCards*3) DESC ---- The syntax is similar to http://www.pythonforbeginners.com/lists/list-comprehensions-in-python/[Python's list comprehesions] and there are a http://docs.neo4j.org/chunked/milestone/syntax-collections.html#_list_comprehension[collection of examples on the manual] that you can follow. A query I wanted to write in May, but had to park until list comprehensions were implemented, is the following one which finds the top 5 scorers for each month and returns their goal tally as well: [source,cypher] ---- START month = node:months('name:*') MATCH month-[:in_month]-game-[:scored_in]-player WITH month, player, COUNT(game) AS games ORDER BY games DESC WITH month, [x IN COLLECT([player.name, games])[0..5] | x[0]] AS players, [x IN COLLECT([player.name, games])[0..5] | x[1]] AS goals ORDER BY month.position RETURN month.name, players, goals ---- My previous attempt was littered with calls to +++<cite>+++HEAD+++</cite>+++ and +++<cite>+++TAIL+++</cite>+++ but this version is much more concise. This is what it returns: [source,bash] ---- ==> +--------------------------------------------------------------------------------------------------------------------+ ==> | month.name | players | goals | ==> +--------------------------------------------------------------------------------------------------------------------+ ==> | "August" | ["Michu","Nathan Dyer","Fernando Torres","Mladen Petric","Damien Duff"] | [3,2,2,2,2] | ==> | "September" | ["Demba Ba","Steven Fletcher","Peter Crouch","Robin Van Persie","Luis Suárez"] | [5,5,4,4,4] | ==> | "October" | ["Juan Mata","Wayne Rooney","Jose Fonte","Michu","Grant Holt"] | [3,2,2,2,2] | ==> | "November" | ["Marouane Fellaini","Luis Suárez","Gareth Bale","Sergio Agüero","Olivier Giroud"] | [4,4,3,3,3] | ==> | "December" | ["Demba Ba","Wayne Rooney","Robin Van Persie","Michu","Theo Walcott"] | [5,5,5,5,4] | ==> | "January" | ["Adam Le Fondre","Luis Suárez","Robin Van Persie","Frank Lampard","Leighton Baines"] | [5,4,4,3,3] | ==> | "February" | ["Gareth Bale","Romelu Lukaku","Moussa Sissoko","Christian Benteke","Santi Cazorla"] | [5,3,3,3,3] | ==> | "March" | ["Luis Suárez","Jan Vertonghen","Christian Benteke","Shinji Kagawa","Stewart Downing"] | [4,3,3,3,2] | ==> | "April" | ["Robin Van Persie","Christian Benteke","Daniel Sturridge","Oscar","Andrew Carroll"] | [6,4,3,2,2] | ==> | "May" | ["Grant Holt","Romelu Lukaku","Daniel Sturridge","Kevin Nolan","Theo Walcott"] | [3,3,3,3,2] | ==> +--------------------------------------------------------------------------------------------------------------------+ ==> 10 rows ---- If you like cypher and haven't played around with list comprehensions yet I'd recommend it - this syntax will help a great deal in reducing the complexity of some queries.

neo4jcypher-translating-1-9-filter-queries-to-use-2-0-list-comprehensions

https://markhneedham.com/blog/2013/09/30/neo4jcypher-translating-1-9-filter-queries-to-use-2-0-list-comprehensions

2013-09-30 20:26:35

Elo Rating System: Ranking Champions League teams using Clojure Part 2

A few weeks ago I wrote about http://www.markhneedham.com/blog/2013/08/31/elo-rating-system-ranking-champions-league-teams-using-clojure/[ranking Champions League teams using the Elo Rating algorithm], and since I wrote that post I've collated data for 10 years worth of matches so I thought an update was in order. After extracting the details of all those matches I https://github.com/mneedham/ranking-algorithms/blob/867941c1569075315d0927a842c6adcbb2621e65/data/cl-matches.json[saved them to a JSON file] so that I wouldn't have to parse the HTML pages every time I tweaked the algorithm. This should also make it easier for other people to play with the data. I described the algorithm in the previous post and had analysed the rankings for one season. However, it was difficult to understand why teams has been ranked in a certain order so I drilled into the data to find out. Since the 2012/2013 season is the freshest in my memory I started with that. The first thing to do was load https://github.com/mneedham/ranking-algorithms/blob/27f94ccf1fc6c63663c8b3d512a2470330585803/data/cl-matches-2013.json[the matches] from disk: ~~~lisp (ns ranking-algorithms.uefa (:require [clj-time.format :as f]) (:require [clojure.data.json :as json])) (defn as-date [date-field] (f/parse (f/formatter "dd MMM YYYY") date-field )) (defn date-aware-value-reader [key value] (if (= key :date) (as-date value) value)) (defn read-from-file [file] (json/read-str (slurp file) :value-fn date-aware-value-reader :key-fn keyword)) ~~~ I've written previously about http://www.markhneedham.com/blog/2013/09/26/clojure-writing-json-to-a-file-exception-dont-know-how-to-write-json-of-class-org-joda-time-datetime/[reifying a date masquerading as a string] but for now we want to give those matches a name and then process them. ~~~lisp > (def the-matches (read-from-file "data/cl-matches-2013.json")) #'ranking-algorithms.uefa/the-matches > (count the-matches) 213 ~~~ I already had a function +++<cite>+++https://github.com/mneedham/ranking-algorithms/blob/27f94ccf1fc6c63663c8b3d512a2470330585803/src/ranking_algorithms/core.clj#L28[top-teams]+++</cite>+++ which would apply the Elo algorithm across the matches, but since I wanted to drill into each team's performance I wrapped that function in another one called +++<cite>+++https://github.com/mneedham/ranking-algorithms/blob/27f94ccf1fc6c63663c8b3d512a2470330585803/src/ranking_algorithms/core.clj#L121[print-top-teams]+++</cite>+++: ~~~lisp (comment "other functions excluded for brevity") (defn format-for-printing [all-matches idx [team ranking & [rd]]] (let [team-matches (show-matches team all-matches)] (merge {:rank (inc idx) :team team :ranking ranking :rd rd :round (performance team-matches)} (match-record team-matches)))) (defn print-top-teams ([number all-matches] (print-top-teams number all-matches {})) ([number all-matches base-rankings] (clojure.pprint/print-table [:rank :team :ranking :round :wins :draw :loses] (map-indexed (partial format-for-printing all-matches) (top-teams number all-matches base-rankings))))) ~~~ ~~~lisp > (ranking-algorithms.core/print-top-teams 10 the-matches) ======================================================================== :rank | :team | :ranking | :round | :wins | :draw | :loses ======================================================================== 1 | Bayern | 1272.74 | Final | 10 | 1 | 2 2 | PSG | 1230.02 | Quarter-finals | 6 | 3 | 1 3 | Dortmund | 1220.96 | Final | 7 | 4 | 2 4 | Real Madrid | 1220.33 | Semi-finals | 6 | 3 | 3 5 | Porto | 1216.97 | Round of 16 | 5 | 1 | 2 6 | CFR Cluj | 1216.56 | Group stage | 7 | 1 | 2 7 | Galatasaray | 1215.56 | Quarter-finals | 5 | 2 | 3 8 | Juventus | 1214.0 | Quarter-finals | 5 | 3 | 2 9 | Málaga | 1211.53 | Quarter-finals | 5 | 5 | 2 10 | Valencia | 1211.0 | Round of 16 | 4 | 2 | 2 ======================================================================== ~~~ _I've excluded most of the functions but you can find the source in https://github.com/mneedham/ranking-algorithms/blob/27f94ccf1fc6c63663c8b3d512a2470330585803/src/ranking_algorithms/core.clj[core.clj] on github._ Clojure-wise I learnt about the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.pprint/print-table[print-table]+++</cite>+++ function which came in handy and Elo-wise I realised that the ranking places a heavy emphasis on winning matches. If you follow the Champions League closely you'll have noticed that Barcelona are missing from the top 10 despite reaching the Semi Final. The Elo algorithm actually ranks them in 65th position: ~~~lisp ========================================================================================= :rank | :team | :ranking | :round | :wins | :draw | :loses ========================================================================================= 63 | Motherwell | 1195.04 | Third qualifying round | 0 | 0 | 2 64 | Feyenoord | 1195.04 | Third qualifying round | 0 | 0 | 2 65 | Barcelona | 1194.68 | Semi-finals | 5 | 3 | 4 66 | BATE | 1194.36 | Group stage | 5 | 3 | 4 67 | Anderlecht | 1193.41 | Group stage | 4 | 2 | 4 ========================================================================================= ~~~ == It's all about winning I thought there might be a bug in my implementation but having looked through it multiple times, Barcelona's low ranking results from losing multiple games - to Celtic, AC Milan and twice to Bayern Munich - and progressing from their Quarter Final tie against PSG without winning either match. I did apply a higher weighting to matches won later on in the competition but otherwise the Elo algorithm doesn't take into account progress in a tournament. == Low variation in rankings The initial ranking of each team was 1200, so I was surprised to see that the top ranked team had only achieved a ranking of 1272 - I expected it to be higher. I read a bit more about the algorithm and learnt that a 200 points gap in ranking signifies that the higher ranked team should win 75% of the time. For this data set the top ranked team has 1272 points and the lowest ranked team has 1171 points so we probably need to tweak the algorithm to make it more accurate. == Accuracy of the Elo algorithm My understanding of the Elo algorithm is that it becomes more accurate as teams play more matches so I decided to try it out on all the matches from 2004 - 2012. I adapted the +++<cite>+++print-top-teams+++</cite>+++ function to exclude ':round' since it doesn't make sense in this context: ~~~lisp (comment "I really need to pull out the printing stuff into a function but I'm lazy so I haven't\...yet") (defn print-top-teams-without-round ([number all-matches] (print-top-teams-without-round number all-matches {})) ([number all-matches base-rankings] (clojure.pprint/print-table [:rank :team :ranking :wins :draw :loses] (map-indexed (partial format-for-printing all-matches) (top-teams number all-matches base-rankings))))) ~~~ If we evaluate that function we see the following rankings: ~~~lisp > (def the-matches (read-from-file "data/cl-matches-2004-2012.json")) #'ranking-algorithms.uefa/the-matches > (ranking-algorithms.core/print-top-teams-without-round 10 the-matches) ========================================================== :rank | :team | :ranking | :wins | :draw | :loses ========================================================== 1 | Barcelona | 1383.85 | 55 | 25 | 12 2 | Man. United | 1343.54 | 49 | 21 | 14 3 | Chelsea | 1322.0 | 44 | 27 | 17 4 | Real Madrid | 1317.68 | 42 | 14 | 18 5 | Bayern | 1306.18 | 42 | 13 | 19 6 | Arsenal | 1276.83 | 47 | 21 | 18 7 | Liverpool | 1272.52 | 41 | 17 | 17 8 | Internazionale | 1260.27 | 36 | 18 | 21 9 | Milan | 1257.63 | 34 | 22 | 18 10 | Bordeaux | 1243.04 | 12 | 3 | 7 ========================================================== ~~~ The only finalists missing from this list are Monaco and Porto who contested the final in 2004 but haven't reached that level of performance since. Bordeaux are the only unlikely entry in this list and have played ~60 games less than the other teams which suggests that we might not have as much confidence in their ranking. It was at this stage that I started looking at the http://glicko.net/glicko/glicko.pdf[Glicko algorithm] which calculates a rating reliability as well as the rating itself. I've https://github.com/mneedham/ranking-algorithms[added instructions to the github README] showing some examples but if you have any questions feel free to ping me on here or https://twitter.com/markhneedham[twitter].

elo-rating-system-ranking-champions-league-teams-using-clojure-part-2

https://markhneedham.com/blog/2013/09/30/elo-rating-system-ranking-champions-league-teams-using-clojure-part-2

2013-09-23 21:42:12

Clojure: Anonymous functions using short notation and the 'ArityException Wrong number of args (0) passed to: PersistentVector'

In the time I've spent playing around with Clojure one thing I've always got confused by is the error message you get when trying to return a vector using the anonymous function shorthand. For example, if we want function which creates a vector with the values 1, 2, and the argument passed into the function we could write the following: [source,lisp] ---- > ((fn [x] [1 2 x]) 6) [1 2 6] ---- However, when I tried to convert it to the shorthand '#()' syntax I got the following exception: [source,lisp] ---- > (#([1 2 %]) 6) clojure.lang.ArityException: Wrong number of args (0) passed to: PersistentVector AFn.java:437 clojure.lang.AFn.throwArity AFn.java:35 clojure.lang.AFn.invoke NO_SOURCE_FILE:1 user/eval575[fn] NO_SOURCE_FILE:1 user/eval575 ---- On previous occasions I've just stopped there and gone back to the long hand notation but this time I wanted to figure out why it didn't work as I expected. I came across http://stackoverflow.com/questions/13204993/anonymous-function-shorthand[this StackOverflow post] which explained the way the shorthand gets expanded: [source,lisp] ---- #() becomes (fn [arg1 arg2] (...)) ---- which means that: [source,lisp] ---- #(([1 2 %]) 6) becomes ((fn [arg] ([1 2 arg])) 6) ---- We are evaluating the vector +++<cite>+++[1 2 arg]+++</cite>+++ as a function but aren't passing any arguments to it. One way it can be used as a function is if we want to return a value at a specific index e.g. [source,lisp] ---- > ([1 2 6] 2) 6 ---- We don't want to evaluate a vector as a function, rather we want to return the vector using the shorthand syntax. To do that we need to find a function which will return the argument passed to it and then pass the vector to that function. The +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/identity[identity]+++</cite>+++ function is one such function: [source,lisp] ---- > (#(identity [1 2 %]) 6) [1 2 6] ---- Or if we want to be more concise the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/-%3E[thread-first (\->)]+++</cite>+++ works too: [source,lisp] ---- > (#(-> [1 2 %]) 6) [1 2 6] ----

clojure-anonymous-functions-using-short-notation-and-the-arityexception-wrong-number-of-args-0-passed-to-persistentvector

https://markhneedham.com/blog/2013/09/23/clojure-anonymous-functions-using-short-notation-and-the-arityexception-wrong-number-of-args-0-passed-to-persistentvector

2013-09-23 22:16:29

cURL: POST/Upload multi part form

I've been doing some work which involved uploading a couple of files from a HTML form and I wanted to check that the server side code was working by executing a cURL command rather than using the browser. The form looks like this: [source,html] ---- <form action="http://foobar.com" method="POST" enctype="multipart/form-data"> <p> <label for="nodes">File 1:</label> <input type="file" name="file1" id="file1"> </p> <p> <label for="relationships">File 2:</label> <input type="file" name="file2" id="file2"> </p> <input type="submit" name="submit" value="Submit"> </form> ---- If we convert the POST request from the browser into a cURL equivalent we end up with the following: [source,bash] ---- curl 'http://foobar.com' -H 'Origin: null' -H 'Accept-Encoding: gzip,deflate,sdch' -H 'Host: foobar.com:7474' -H 'Accept-Language: en-US,en;q=0.8' -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1500.95 Safari/537.36' -H 'Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryMxYFIg6GFEIPAe6V' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' -H 'Cache-Control: max-age=0' -H 'Cookie: splashShown1.6=1; undefined=0; _mkto_trk=id:773-GON-065&token:_mch-localhost-1373821432078-37666; JSESSIONID=123cbkxby1rtcj3dwipqzs7yu' -H 'Connection: keep-alive' --data-binary $'------WebKitFormBoundaryMxYFIg6GFEIPAe6V\r\nContent-Disposition: form-data; name="file1"; filename="file1.csv"\r\nContent-Type: text/csv\r\n\r\n\r\n------WebKitFormBoundaryMxYFIg6GFEIPAe6V\r\nContent-Disposition: form-data; name="file2"; filename="file2.csv"\r\nContent-Type: text/csv\r\n\r\n\r\n------WebKitFormBoundaryMxYFIg6GFEIPAe6V\r\nContent-Disposition: form-data; name="submit"\r\n\r\nSubmit\r\n------WebKitFormBoundaryMxYFIg6GFEIPAe6V--\r\n' --compressed ---- I tried executing this command but I couldn't quite get it to work, and in any case it seemed extremely complicated. Thankfully, I came across a http://curl.haxx.se/docs/httpscripting.html[cURL tutorial] which described a much simpler alternative which does work: [source,bash] ---- curl --form file1=@file1.csv --form file2=@file2.csv --form press=submit http://foobar.com ---- I knew it couldn't be that complicated!

curl-postupload-multi-part-form

https://markhneedham.com/blog/2013/09/23/curl-postupload-multi-part-form

2013-09-14 00:06:37

jackson-core-asl - java.lang.AbstractMethodError: org.codehaus.jackson.JsonNode.getValueAsText()Ljava/lang/String;

https://twitter.com/iansrobinson[Ian] and I were doing a bit of work on an internal application which processes JSON messages and interacts with AWS and we started seeing the following exception after doing an upgrade of +++<cite>+++http://mvnrepository.com/artifact/org.codehaus.jackson/jackson-mapper-asl[jackson-mapper-asl]+++</cite>+++ from 1.8.9 to 1.9.13: [source,text] ---- 2013-09-13 11:01:50 +0000: Exception while handling {MessageId: 7e695fb3-549a-4b 40-b1cf-9dbc5e97a8df, ... } java.lang.AbstractMethodError: org.codehaus.jackson.JsonNode.getValueAsText()Lja va/lang/String; ... at com.amazonaws.services.sqs.AmazonSQSAsyncClient$20.call(AmazonSQSAsyn cClient.java:1200) at com.amazonaws.services.sqs.AmazonSQSAsyncClient$20.call(AmazonSQSAsyn cClient.java:1191) at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:334) at java.util.concurrent.FutureTask.run(FutureTask.java:166) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor. java:1145) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor .java:615) at java.lang.Thread.run(Thread.java:724) ---- I'd not seen this exception before but we figured that it was probably happening because we had http://stackoverflow.com/questions/14954738/runtime-exception-with-jersey-java-lang-abstractmethoderror[conflicting versions of some Jackson related JAR on the class path]. We could see in the external libraries section of IntelliJ that we had both the 1.8.9 and 1.9.13 versions of jackson-mapper-asl but we weren't sure which dependency was pulling in the earlier version. https://twitter.com/apcj[Alistair] pointed out quite a neat command you can pass to Maven which shows transitive dependencies so we gave that a try: [source,bash] ---- $ mvn dependency:tree ... [INFO] --- maven-dependency-plugin:2.1:tree (default-cli) @ load-generator --- [INFO] +- com.amazonaws:aws-java-sdk:jar:1.5.6:compile [INFO] | +- commons-logging:commons-logging:jar:1.1.1:compile [INFO] | +- org.apache.httpcomponents:httpclient:jar:4.2.2:compile (version managed from 4.2) [INFO] | +- commons-codec:commons-codec:jar:1.6:compile [INFO] | \- org.codehaus.jackson:jackson-core-asl:jar:1.8.9:compile ... [INFO] +- org.codehaus.jackson:jackson-mapper-asl:jar:1.9.13:compile [INFO] | \- org.codehaus.jackson:jackson-core-asl:jar:1.9.13:compile ... ---- As you can see, we have two different versions of the +++<cite>+++json-core-asl+++</cite>+++ JAR and the earlier version was being pulled in by the +++<cite>+++aws-java-sdk+++</cite>+++. We http://maven.40175.n5.nabble.com/Force-higher-version-dependency-td90566.html[excluded its transitive dependency] by changing our pom file to read like this: ~~~xml +++<dependency>++++++<groupId>+++com.amazonaws+++</groupId>+++ +++<artifactId>+++aws-java-sdk+++</artifactId>+++ +++<version>+++1.5.6+++</version>+++ +++<exclusions>++++++<exclusion>++++++<groupId>+++org.codehaus.jackson+++</groupId>+++ +++<artifactId>+++jackson-core-asl+++</artifactId>++++++</exclusion>++++++</exclusions>++++++</dependency>+++ ~~~ After that everything worked swimmingly.

jackson-core-asl-java-lang-abstractmethoderror-org-codehaus-jackson-jsonnode-getvalueastextljavalangstring

https://markhneedham.com/blog/2013/09/14/jackson-core-asl-java-lang-abstractmethoderror-org-codehaus-jackson-jsonnode-getvalueastextljavalangstring

2013-09-14 21:02:30

Glicko Rating System: A simple example using Clojure

A couple of weeks ago I wrote about the http://www.markhneedham.com/blog/2013/08/31/elo-rating-system-ranking-champions-league-teams-using-clojure/[Elo Rating system] and when reading more about it I learnt that one of its weaknesses is that it doesn't take into account the reliability of a players' rating. For example, a player may not have played for a long time. When they next play a match we shouldn't assume that the accuracy of that rating is the same as for another player with the same rating but who plays regularly. Mark Glickman wrote the http://www.glicko.net/glicko/glicko.pdf[Glicko Rating System] to take the uncertainty into account by introducing a 'ratings deviation' (RD). A low RD indicates that a player competes frequently and a higher RD indicates that they don't. One other difference between Glicko and Elo is the following: ____ It is interesting to note that, in the Glicko system, rating changes are not balanced as they usually are in the Elo system. If one player's rating increases by x, the opponent's rating does not usually decrease by x as in the Elo system. In fact, in the Glicko system, the amount by which the opponent's rating decreases is governed by both players' RD's. ____ The RD value effectively tells us the range in which the player's actual rating probably exists. i.e. a 95% confidence interval. e.g. if a player has a rating of 1850 and a RD of 50 then the interval is 1750 - 1950 or +++<cite>+++(Rating - 2*RD)+++</cite>+++ - +++<cite>+++(Rating + 2*RD)+++</cite>+++ The algorithm has 2 steps: . Determine a rating and RD for each player at the onset of the rating period. If the player is unrated use a value of 1500 and RD of 350. If they do have a rating we'll calculate the new RD from the old RD using this formula: + image::{{<siteurl>}}/uploads/2013/09/glicko-rd.jpg[Glicko rd,213] + where: ** t is the number of rating periods since last competition (e.g., if the player competed in the most recent rating period, t = 1) ** c is a constant that governs the increase in uncertainty over time. . Update each players rating and RD separately using the following formula: + image::{{<siteurl>}}/uploads/2013/09/glicko.jpg[Glicko,561] + where: ** r is the player's pre-period rating ** RD is the player's pre-period ratings deviation ** r~1~, r~2~,\...,r~m~ are the pre-period ratings of their opponents ** RD~1~, RD~2~,\...,RD~m~ are the pre-period ratings deviations of their opponents ** s~1~, s~2~,\...,2~m~ are the scores against the opponents. 1 is a win, 1/2 is a draw, 0 is a defeat. ** r' is the player's post-period rating ** RD' is the player's post-period ratings deviation The http://www.glicko.net/glicko/glicko.pdf[paper] provides an example to follow and includes the intermediate workings which made it easier to build the algorithm one function at a time. The +++<cite>+++q+++</cite>+++ function was the simplest to implement so I created that and the +++<cite>+++g+++</cite>+++ function at the same time: [source,lisp] ---- (ns ranking-algorithms.glicko (:require [clojure.math.numeric-tower :as math])) (def q (/ (java.lang.Math/log 10) 400)) (defn g [rd] (/ 1 (java.lang.Math/sqrt (+ 1 (/ (* 3 (math/expt q 2) (math/expt rd 2)) (math/expt ( . Math PI) 2)))))) ---- We can use the following table to check we get the right results when we call it.: image::{{<siteurl>}}/uploads/2013/09/glicko-table.jpg[Glicko table,419] [source,lisp] ---- > (g 30) 0.9954980060779481 > (g 100) 0.953148974234587 > (g 300) 0.7242354637384434 ---- The next easiest function to write was the +++<cite>+++E+++</cite>+++ function: [source,lisp] ---- (defn e [rating opponent-rating opponent-rd] (/ 1 (+ 1 (math/expt 10 (/ (* (- (g opponent-rd)) (- rating opponent-rating)) 400))))) ---- And if we test that assuming that we have a rating of 1500 with a RD of 200: [source,lisp] ---- > (e 1500 1400 30) 0.639467736007921 > (e 1500 1550 100) 0.43184235355955686 > (e 1500 1700 300) 0.30284072524764 ---- Finally we need to write the +++<cite>+++d^2^+++</cite>+++ supporting function: [source,lisp] ---- (defn d2 [opponents] (/ 1 (* (math/expt q 2) (reduce process-opponent 0 opponents)))) (defn process-opponent [total opponent] (let [{:keys [g e]} opponent] (+ total (* (math/expt g 2) e (- 1 e))))) ---- In this function we need to sum a combination of the +++<cite>+++g+++</cite>+++ and +++<cite>+++e+++</cite>+++ values we calculated earlier for each opponent so we can use a reduce over a collection of those values for each opponent to do that: [source,lisp] ---- > (d2 [{:g (g 30) :e (e 1500 1400 30)} {:g (g 100) :e (e 1500 1550 100)} {:g (g 300) :e (e 1500 1700 300)}]) 53685.74290197874 ---- I get a slightly different value for this function which I think is because I didn't round the intermediate values to 2 decimal places as the example does. Now we can introduce the +++<cite>+++r'+++</cite>+++ function which returns our ranking after taking the matches against these opponents into account: [source,lisp] ---- (defn update-ranking [ranking-delta opponent] (let [{:keys [ranking opponent-ranking opponent-ranking-rd score]} opponent] (+ ranking-delta (* (g opponent-ranking-rd) (- score (e ranking opponent-ranking opponent-ranking-rd)))))) (defn g-and-e [ranking {o-rd :opponent-ranking-rd o-ranking :opponent-ranking}] {:g (g o-rd) :e (e ranking o-ranking o-rd)}) (defn ranking-after-round [{ ranking :ranking rd :ranking-rd opponents :opponents}] (+ ranking (* (/ q (+ (/ 1 (math/expt rd 2)) (/ 1 (d2 (map (partial g-and-e ranking) opponents))))) (reduce update-ranking 0 (map #(assoc-in % [:ranking] ranking) opponents))))) ---- One thing I wasn't sure about here was the use of +++<cite>+++partial+++</cite>+++ which is a bit of a Haskell idiom. I'm not sure what the favoured approach is in Clojure land yet. If we execute that function we get the expected result: [source,lisp] ---- > (ranking-after-round { :ranking 1500 :ranking-rd 200 :opponents[{:opponent-ranking 1400 :opponent-ranking-rd 30 :score 1} {:opponent-ranking 1550 :opponent-ranking-rd 100 :score 0} {:opponent-ranking 1700 :opponent-ranking-rd 300 :score 0}]}) 1464.1064627569112 ---- The only function missing now is +++<cite>+++RD'+++</cite>+++ which returns our RD after taking these matches into account: [source,lisp] ---- (defn rd-after-round [{ ranking :ranking rd :ranking-rd opponents :opponents}] (java.lang.Math/sqrt (/ 1 (+ (/ 1 (math/expt rd 2) ) (/ 1 (d2 (map (partial g-and-e ranking) opponents))))))) ---- If we execute that function we get the expected result and we're done! [source,lisp] ---- > (rd-after-round { :ranking 1500 :ranking-rd 200 :opponents[{:opponent-ranking 1400 :opponent-ranking-rd 30 :score 1} {:opponent-ranking 1550 :opponent-ranking-rd 100 :score 0} {:opponent-ranking 1700 :opponent-ranking-rd 300 :score 0}]}) 151.39890244796933 ---- The next step is to run this algorithm against the football data and see if its results differ to the ones I got with the Elo algorithm. I'm still not quite sure what I should set the rating period to. My initial thinking was that the rating period could be a season but that would mean that a team's rating only really makes sense after a few seasons of matches. The https://github.com/mneedham/ranking-algorithms/blob/master/src/ranking_algorithms/glicko.clj[code is on github]if you want to play with it and if you have any suggestions on how to make the code more idiomatic I'd love to hear them.

glicko-rating-system-a-simple-example-using-clojure

https://markhneedham.com/blog/2013/09/14/glicko-rating-system-a-simple-example-using-clojure

2013-09-14 01:24:51

Clojure: All things regex

I've been doing some http://www.markhneedham.com/blog/2013/08/26/clojureenlive-screen-scraping-a-html-file-from-disk/[scrapping of web pages recently using Clojure and Enlive] and as part of that I've had to write regular expressions to extract the data I'm interested in. On my travels I've come across a few different functions and I'm never sure which is the right one to use so I thought I'd document what I've tried for future me. == Check if regex matches The first regex I wrote was while scrapping the http://www.rsssf.com/ec/ec200203det.html[Champions League results] from the Rec.Sport.Soccer Statistics Foundation and I wanted to determine which spans contained the match result and which didn't. A matching line would look like this: [source,text] ---- Real Madrid-Juventus Turijn 2 - 1 ---- And a non matching one like this: [source,text] ---- 53’Nedved 0-1, 66'Xavi Hernández 1-1, 114’Zalayeta 1-2 ---- I wrote the following regex to detect match results: [source,text] ---- [a-zA-Z\s]+-[a-zA-Z\s]+ [0-9][\s]?.[\s]?[0-9] ---- I then wrote the following function using +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-matches[re-matches]+++</cite>+++ which would return true or false depending on the input: [source,lisp] ---- (defn recognise-match? [row] (not (clojure.string/blank? (re-matches #"[a-zA-Z\s]+-[a-zA-Z\s]+ [0-9][\s]?.[\s]?[0-9]" row)))) ---- [source,lisp] ---- > (recognise-match? "Real Madrid-Juventus Turijn 2 - 1") true > (recognise-match? "53’Nedved 0-1, 66'Xavi Hernández 1-1, 114’Zalayeta 1-2") false ---- +++<cite>+++re-matches+++</cite>+++ only returns matches if the whole string matches the pattern which means if we had a line with some spurious text after the score it wouldn't match: [source,lisp] ---- > (recognise-match? "Real Madrid-Juventus Turijn 2 - 1 abc") false ---- If we don't mind that and we just want some part of the string to match our pattern then we can use +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-find[re-find]+++</cite>+++ instead: [source,lisp] ---- (defn recognise-match? [row] (not (clojure.string/blank? (re-find #"[a-zA-Z\s]+-[a-zA-Z\s]+ [0-9][\s]?.[\s]?[0-9]" row)))) ---- [source,lisp] ---- > (recognise-match? "Real Madrid-Juventus Turijn 2 - 1 abc") true ---- == Extract capture groups The next thing I wanted to do was to capture the teams and the score of the match which I initially did using +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-seq[re-seq]+++</cite>+++: [source,lisp] ---- > (first (re-seq #"([a-zA-Z\s]+)-([a-zA-Z\s]+) ([0-9])[\s]?.[\s]?([0-9])" "FC Valencia-Internazionale Milaan 2 - 1")) ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] ---- I then extracted the various parts like so: [source,lisp] ---- > (def result (first (re-seq #"([a-zA-Z\s]+)-([a-zA-Z\s]+) ([0-9])[\s]?.[\s]?([0-9])" "FC Valencia-Internazionale Milaan 2 - 1"))) > result ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] > (nth result 1) "FC Valencia" > (nth result 2) "Internazionale Milaan" ---- +++<cite>+++re-seq+++</cite>+++ returns a list which contains consecutive matches of the regex. The list will either contain strings if we don't specify capture groups or a vector containing the pattern matched and each of the capture groups. For example if we now match only sequences of A-Z or spaces and remove the rest of the pattern from above we'd get the following results: [source,lisp] ---- > (re-seq #"([a-zA-Z\s]+)" "FC Valencia-Internazionale Milaan 2 - 1") (["FC Valencia" "FC Valencia"] ["Internazionale Milaan " "Internazionale Milaan "] [" " " "] [" " " "]) > (re-seq #"[a-zA-Z\s]+" "FC Valencia-Internazionale Milaan 2 - 1") ("FC Valencia" "Internazionale Milaan " " " " ") ---- In our case +++<cite>+++re-find+++</cite>+++ or +++<cite>+++re-matches+++</cite>+++ actually makes more sense since we only want to match the pattern once. If there are further matches after this those aren't included in the results. e.g. [source,lisp] ---- > (re-find #"[a-zA-Z\s]+" "FC Valencia-Internazionale Milaan 2 - 1") "FC Valencia" > (re-matches #"[a-zA-Z\s]*" "FC Valencia-Internazionale Milaan 2 - 1") nil ---- +++<cite>+++re-matches+++</cite>+++ returns nil here because there are characters in the string which don't match the pattern i.e. the hyphen between the two scores. If we tie that in with our capture groups we end up with the following: [source,lisp] ---- > (def result (re-find #"([a-zA-Z\s]+)-([a-zA-Z\s]+) ([0-9])[\s]?.[\s]?([0-9])" "FC Valencia-Internazionale Milaan 2 - 1")) > result ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] > (nth result 1) "FC Valencia" > (nth result 2) "Internazionale Milaan" ---- I also came across the +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-pattern[re-pattern]+++</cite>+++ function which provides a more verbose way of creating a pattern and then evaluating it with +++<cite>+++re-find+++</cite>+++: [source,lisp] ---- > (re-find (re-pattern "([a-zA-Z\\s]+)-([a-zA-Z\\s]+) ([0-9])[\\s]?.[\\s]?([0-9])") "FC Valencia-Internazionale Milaan 2 - 1") ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] ---- One difference here is that I had to escape the special sequence '\s' otherwise I was getting the following exception: [source,lisp] ---- RuntimeException Unsupported escape character: \s clojure.lang.Util.runtimeException (Util.java:170) ---- I wanted to play around with +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-groups[re-groups]+++</cite>+++ as well but that seemed to throw an exception reasonably frequently when I expected it to work.</cite> The last function I looked at was +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/re-matcher[re-matcher]+++</cite>+++ which seemed to be a long-hand for the '#""' syntax used earlier in the post to define matchers: ~~~lisp > (re-find (re-matcher #"([a-zA-Z\s]+)-([a-zA-Z\s]+) ([0-9])[\s]?.[\s]?([0-9])" "FC Valencia-Internazionale Milaan 2 - 1")) ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] ~~~ == In summary So in summary I think most use cases are covered by +++<cite>+++re-find+++</cite>+++ and +++<cite>+++re-matches+++</cite>+++ and maybe +++<cite>+++re-seq+++</cite>+++ on special occasions. I couldn't see where I'd use the other functions but I'm happy to be proved wrong.

clojure-all-things-regex

https://markhneedham.com/blog/2013/09/14/clojure-all-things-regex

2013-09-22 18:54:47

Clojure: Stripping all the whitespace

When putting together data sets to play around with, one of the more boring tasks is stripping out characters that you're not interested in and more often than not those characters are white spaces. Since I've been building data sets using Clojure I wanted to write a function that would do this for me. I started out with the following string: [source,lisp] ---- (def word " with a little bit of space we can make it through the night ") ---- which I wanted to format in such a way that there would be a maximum of one space between each word. I start out by using the +++<cite>+++http://clojure.github.io/clojure/clojure.string-api.html#clojure.string/trim[trim]+++</cite>+++ function but that only removes white space from the beginning and end of a string: [source,lisp] ---- > (clojure.string/trim word) "with a little bit of space we can make it through the night" ---- I wanted to get rid of the space in between 'a' and 'little' as well so I wrote the following code to split on a space and filter out any excess spaces that still remained before joining the words back together: [source,lisp] ---- > (clojure.string/join " " (filter #(not (clojure.string/blank? %)) (clojure.string/split word #" "))) "with a little bit of space we can make it through the night" ---- I wanted to try and make it a bit easier to read by using the http://clojuredocs.org/clojure_core/clojure.core/-%3E%3E[thread last (\->>) macro] but that didn't work as well as I'd hoped because +++<cite>+++clojure.string/split+++</cite>+++ doesn't take the string in as its last parameter: [source,lisp] ---- > (->> (clojure.string/split word #" ") (filter #(not (clojure.string/blank? %))) (clojure.string/join " ")) "with a little bit of space we can make it through the night" ---- I worked around it by creating a specific function for splitting on a space: [source,lisp] ---- (defn split-on-space [word] (clojure.string/split word #"\s")) ---- which means we can now chain everything together nicely: [source,lisp] ---- > (->> word split-on-space (filter #(not (clojure.string/blank? %))) (clojure.string/join " ")) "with a little bit of space we can make it through the night" ---- I couldn't find a cleaner way to do this but I'm sure there is one and my googling just isn't up to scratch so do let me know in the comments!

clojure-stripping-all-the-whitespace

https://markhneedham.com/blog/2013/09/22/clojure-stripping-all-the-whitespace

2013-09-22 23:07:04

Clojure/Emacs/nrepl: Stacktrace-less error messages

Ever since I started using the Emacs + nrepl combination to play around with Clojure I've been getting fairly non descript error messages whenever I pass the wrong parameters to a function. For example if I try to update a non existent key in a form I get a Null Pointer Exception: [source,lisp] ---- > (update-in {} [:mark] inc) NullPointerException clojure.lang.Numbers.ops (Numbers.java:942) ---- In this case it's clear that the hash doesn't have a key ':mark' so the function blows up. However, sometimes the functions are more complicated and this type of reduced stack trace isn't very helpful for working out where the problem lies. I eventually came across https://groups.google.com/forum/#!msg/nrepl-el/x8vhEbckycY/93unZrJI1RkJ[a thread in the nrepl-el forum] where Tim King suggested that adding the following lines to the Emacs configuration file should sort things out: _~/.emacs.d/init.el_ [source,lisp] ---- (setq nrepl-popup-stacktraces nil) (setq nrepl-popup-stacktraces-in-repl t) ---- I added those two lines, restarted Emacs and after calling the function again got a much more detailed stack trace: [source,lisp] ---- > (update-in {} [:mark] inc) java.lang.NullPointerException: Numbers.java:942 clojure.lang.Numbers.ops Numbers.java:110 clojure.lang.Numbers.inc core.clj:863 clojure.core/inc AFn.java:161 clojure.lang.AFn.applyToHelper AFn.java:151 clojure.lang.AFn.applyTo core.clj:603 clojure.core/apply core.clj:5472 clojure.core/update-in RestFn.java:445 clojure.lang.RestFn.invoke NO_SOURCE_FILE:1 user/eval9 ... ---- From reading this stack trace we learn that the problem happens when the +++<cite>+++inc+++</cite>+++ function is called with a parameter of 'nil'. We'd see the same thing if we called it directly: [source,lisp] ---- > (inc nil) java.lang.NullPointerException: Numbers.java:942 clojure.lang.Numbers.ops Numbers.java:110 clojure.lang.Numbers.inc NO_SOURCE_FILE:1 user/eval14 ... ---- Although Clojure error messages do baffle me at times, I hope things will be better now that I'll be able to see on which line the error occurred.

clojureemacsnrepl-stacktrace-less-error-messages

https://markhneedham.com/blog/2013/09/22/clojureemacsnrepl-stacktrace-less-error-messages

2013-09-22 21:23:25

Clojure/Emacs/nrepl: Ctrl X + Ctrl E leads to 'FileNotFoundException Could not locate [...] on classpath'

I've been playing around with Clojure using http://www.gnu.org/software/emacs/[Emacs] and https://github.com/clojure/tools.nrepl[nrepl] recently and my normal work flow is to write some code in Emacs and then have it evaluated in nrepl by typing +++<cite>+++Ctrl X + Ctrl E+++</cite>+++ at the end of the function. I tried this once recently and got the following exception instead of a successful evaluation: [source,text] ---- FileNotFoundException Could not locate ranking_algorithms/ranking__init.class or ranking_algorithms/ranking.clj on classpath: clojure.lang.RT.load (RT.java:432) ---- I was a bit surprised because I had nrepl running already (via +++<cite>+++(Meta + X) + Enter + nrepl-jack-in+++</cite>+++) and I'd only ever seen that exception refer to dependencies which weren't in my project.clj file at the time I launched nrepl. I eventually came across http://stackoverflow.com/questions/15511840/emacs-clojure-compiling-error[this StackOverflow post] which suggested that you either launch nrepl using leiningen and then connect to it from Emacs or have your project.clj open when running +++<cite>+++(Meta + X) + Enter + nrepl-jack-in+++</cite>+++. To launch nrepl from leiningen we'd run the following command from the terminal: [source,bash] ---- $ lein repl nREPL server started on port 52265 REPL-y 0.1.0-beta10 Clojure 1.4.0 Exit: Control+D or (exit) or (quit) Commands: (user/help) Docs: (doc function-name-here) (find-doc "part-of-name-here") Source: (source function-name-here) (user/sourcery function-name-here) Javadoc: (javadoc java-object-or-class-here) Examples from clojuredocs.org: [clojuredocs or cdoc] (user/clojuredocs name-here) (user/clojuredocs "ns-here" "name-here") ---- We can then connect to that nrepl server from Emacs by typing +++<cite>+++(Meta + X) + Enter + nrepl+++</cite>+++ which seems to work quite nicely. To check the +++<cite>+++nrepl-jack-in+++</cite>+++ approach works when we've got project.clj open we need to first kill the existing server by typing +++<cite>+++(Meta + X) + Enter + nrepl-quit+++</cite>+++. Now if we type +++<cite>+++(Meta + X) + Enter + nrepl-jack-in+++</cite>+++ our functions are evaluated correctly and all is well with the world again.

clojureemacsnrepl-ctrl-x-ctrl-e-leads-to-filenotfoundexception-could-not-locate-on-classpath

https://markhneedham.com/blog/2013/09/22/clojureemacsnrepl-ctrl-x-ctrl-e-leads-to-filenotfoundexception-could-not-locate-on-classpath

2013-08-05 22:12:37

Java/JBLAS: Calculating eigenvector centrality of an adjacency matrix

I recently came across a very interesting post by Kieran Healy where he http://kieranhealy.org/blog/archives/2013/06/09/using-metadata-to-find-paul-revere/[runs through a bunch of graph algorithms] to see whether he can detect the most influential people behind the American Revolution based on their membership of various organisations. The first algorithm he looked at was betweenness centrality which http://www.markhneedham.com/blog/2013/07/27/graph-processing-betweeness-centrality-neo4js-cypher-vs-graphstream/[I've looked at previously] and is used to determine the load and importance of a node in a graph. This algorithm would assign a high score to nodes which have a lot of nodes connected to them even if those nodes aren't necessarily influential nodes in the graph. If we want to take the influence of the other nodes into account then we can use an algorithm called https://en.wikipedia.org/wiki/Centrality#Eigenvector_centrality[eigenvector centrality]. ____ Eigenvector centrality is a measure of the influence of a node in a network. It assigns relative scores to all nodes in the network based on the concept that *connections to high-scoring nodes contribute more to the score of the node in question* than equal connections to low-scoring nodes. Google's https://en.wikipedia.org/wiki/PageRank[PageRank] is a variant of the Eigenvector centrality measure. ____ Both PageRank and Eigenvector centrality give us a probability which describes how often we'd end up visiting each node on a random walk around the graph. As far as I can tell there are a couple of differences between PageRank and Eigenvector centrality (but I'm happy to be corrected as I'm still learning this stuff): . PageRank introduces a 'dampening factor' to simulate the idea that some percentage of the time we might decide not to follow any of a node's relationships but instead pick a random node in the graph. . PageRank makes sure that the elements in each column of the adjacency matrix add up to one. Therefore, if our node had a relationship to every other one in the graph then each would only contribute a value of 1/n rather than 1. In this instance since Healy wanted to analyse the influence of people rather than web pages eigenvector centrality makes more sense. Over the past few days I've been trying to understand this topic area a bit better and found the following resources useful: * http://www.youtube.com/watch?v=G4N8vJpf7hM[Introduction to Eigenvalues and Eigenvectors] - video working through a simple matrix * https://www.khanacademy.org/math/linear-algebra/alternate_bases/eigen_everything/v/linear-algebra--eigenvalues-of-a-3x3-matrix[Khan Academy videos] showing how to calculate eigenvalues and eigenvectors for different sized matrices. * http://williamcotton.com/pagerank-explained-with-javascript[PageRank explained in Javascript] - this is probably the best one to start with. * http://in1.csie.ncu.edu.tw/~chia/Course/LinearAlgebra/sec7-2.pdf[Finding the eigenvalues of a matrix] - some reasonably easy to follow examples * http://matrixapps.blogspot.co.uk/2010/07/gould-index-matrix-application-to.html[Gould Index: Matrix Application to Geography] - I think the Gould Index is another name for eigenvector centrality. This works through a couple of different transport based examples and explains the significance of eigenvector centrality in that field. * http://www.math.washington.edu/~morrow/336_11/papers/leo.pdf[Justification and Application of Eigenvector Centrality] - this runs through a few examples and explains the http://www.math.harvard.edu/~knill/teaching/math19b_2011/handouts/lecture34.pdf[Perron-Frobenius Theorem] - a theorem which explains that if all values in a matrix are positive then there will be a unique maximal eigenvalue. We can then use this principal eigenvalue to calculate an eigenvector which describes the centrality of each of the nodes in the graph. * http://www.jstor.org/discover/10.2307/621372?uid=3738032&uid=2473321943&uid=2&uid=3&uid=60&sid=21102528715777[On the geographical Interpretation of Eigenvalues] - This paper goes through various different transport networks and shows what we can learn by calculating the eigenvector centrality. This is behind JSTOR login but you can view it online for free once you sign up for an account.</p> </ul> + I calculated a few made up matrices by hand but found it became too difficult after a 3x3 matrix so I wanted to find a Java based library which I could use instead. + image::{{<siteurl>}}/uploads/2013/08/adjacencymatrix.jpg[Adjacencymatrix,213] + These were the ones that I came across: ** http://mikiobraun.github.io/jblas/[JBLAS] - Linear Algebra for Java ** http://math.nist.gov/javanumerics/jama/[JAMA] - A Java Matrix Package ** http://acs.lbl.gov/software/colt/[Colt] - Advanced Computing for Science ** http://commons.apache.org/proper/commons-math/[Commons Math] - The Apache Commons Mathematics Library ** http://la4j.org/[la4j] - Linear Algebra for Java ** https://github.com/fommil/matrix-toolkits-java[MTJ] - Matrix Toolkits Java + I'd heard of JBLAS before so I thought I'd give that a try on one of the adjacency matrices described in http://matrixapps.blogspot.co.uk/2010/07/gould-index-matrix-application-to.html[Murphy Waggoner's post about the Gould Index] and see if I got the same eigenvector centrality values.</li> The first step was to define the matrix which can be represented as an array of arrays: ~~~java DoubleMatrix matrix = new DoubleMatrix(new double[][] { {1,1,0,0,1,0,0}, {1,1,0,0,1,0,0}, {0,0,1,1,1,0,0}, {0,0,1,1,1,0,0}, {1,1,1,1,1,1,1}, {0,0,0,0,1,1,1}, {0,0,0,0,1,1,1}, }); ~~~ Our next stop is to work out the eigenvalues which we can do using the following function: ~~~java ComplexDoubleMatrix eigenvalues = Eigen.eigenvalues(matrix); for (ComplexDouble eigenvalue : eigenvalues.toArray()) { System.out.print(String.format("%.2f ", eigenvalue.abs())); } ~~~ ~~~text 4.00 2.00 0.00 1.00 2.00 0.00 0.00 ~~~ We want to get the corresponding eigenvector for the eigenvalue of 4 and as far as I can tell the +++<cite>+++Eigen#eigenvectors+++</cite>+++ function returns its values in the same order as the +++<cite>+++Eigen#eigenvalues+++</cite>+++ function so I wrote the following code to work out the principal eigenvector : ~~~java List+++<Double>+++principalEigenvector = getPrincipalEigenvector(matrix); System.out.println("principalEigenvector = " + principalEigenvector); private static List+++<Double>+++getPrincipalEigenvector(DoubleMatrix matrix) { int maxIndex = getMaxIndex(matrix); ComplexDoubleMatrix eigenVectors = Eigen.eigenvectors(matrix)[0]; return getEigenVector(eigenVectors, maxIndex); } private static int getMaxIndex(DoubleMatrix matrix) { ComplexDouble[] doubleMatrix = Eigen.eigenvalues(matrix).toArray(); int maxIndex = 0; for (int i = 0; i < doubleMatrix.length; i++){ double newnumber = doubleMatrix[i].abs(); if ((newnumber > doubleMatrix[maxIndex].abs())){ maxIndex = i; } } return maxIndex; } private static List+++<Double>+++getEigenVector(ComplexDoubleMatrix eigenvector, int columnId) { ComplexDoubleMatrix column = eigenvector.getColumn(columnId); List+++<Double>+++values = new ArrayList+++<Double>+++(); for (ComplexDouble value : column.toArray()) { values.add(value.abs() ); } return values; } ~~~ In +++<cite>+++getMaxIndex+++</cite>+++ we work out which index in the array the largest eigenvalue belongs to so that we can look it up in the array we get from +++<cite>+++Eigen#eigenvectors+++</cite>+++. According to the documentation the eigenvectors are stored in the first matrix we get back which is why we choose that on the second line of +++<cite>+++getPrincipalEigenvector+++</cite>+++. This is the output we get from running that: ~~~text principalEigenvector = [0.3162277660168381, 0.3162277660168376, 0.316227766016838, 0.316227766016838, 0.6324555320336759, 0.316227766016838, 0.316227766016838] ~~~ Finally we normalise the values so that they all add together to equal 1 which means our result will tell the % of time that a random walk would take you to this node: ~~~java System.out.println("normalisedPrincipalEigenvector = " + normalised(principalEigenvector)); private static List+++<Double>+++normalised(List+++<Double>+++principalEigenvector) { double total = sum(principalEigenvector); List+++<Double>+++normalisedValues = new ArrayList+++<Double>+++(); for (Double aDouble : principalEigenvector) { normalisedValues.add(aDouble / total); } return normalisedValues; } private static double sum(List+++<Double>+++principalEigenvector) { double total = 0; for (Double aDouble : principalEigenvector) { total += aDouble; } return total; } ~~~ ~~~text normalisedPrincipalEigenvector = [0.12500000000000006, 0.12499999999999988, 0.12500000000000003, 0.12500000000000003, 0.25, 0.12500000000000003, 0.12500000000000003] ~~~ We get the same answers as Murphy does so I guess the library is working correctly! Next I think I should do some experimentation with PageRank on this graph to see how its measure of centrality differs.+++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>++++++</Double>+++

javajblas-calculating-eigenvector-centrality-of-an-adjacency-matrix

https://markhneedham.com/blog/2013/08/05/javajblas-calculating-eigenvector-centrality-of-an-adjacency-matrix

2013-08-11 08:07:01

Jersey Client: com.sun.jersey.api.client.UniformInterfaceException

As I mentioned in http://www.markhneedham.com/blog/2013/07/28/jersey-client-testing-external-calls/[a post a couple of weeks ago] we've been doing some which involved calling the neo4j server's http://docs.neo4j.org/chunked/stable/ha-rest-info.html#_the_endpoints[HA URI] to determine whether a machine was slave or master. We started off with the following code using https://jersey.java.net/documentation/latest/user-guide.html#client[jersey-client]: [source,java] ---- public class HaSpike { public static void main(String[] args) { String response = client() .resource("http://localhost:7474/db/manage/server/ha/slave") .accept(MediaType.TEXT_PLAIN) .get(String.class); System.out.println("response = " + response); } private static Client client() { DefaultClientConfig defaultClientConfig = new DefaultClientConfig(); defaultClientConfig.getClasses().add(JacksonJsonProvider.class); return Client.create(defaultClientConfig); } } ---- which works fine when the server is actually a slave: [source,text] ---- response = true ---- but blows up in style if the server is the master: [source,text] ---- Exception in thread "main" com.sun.jersey.api.client.UniformInterfaceException: GET http://localhost:7474/db/manage/server/ha/slave returned a response status of 404 Not Found at com.sun.jersey.api.client.WebResource.handle(WebResource.java:686) at com.sun.jersey.api.client.WebResource.access$200(WebResource.java:74) at com.sun.jersey.api.client.WebResource$Builder.get(WebResource.java:507) at HaSpike.main(HaSpike.java:10) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) ---- We return a 404 status code from that URI if you're not a slave because it simplifies things for upstream load balancers but I thought Jersey would just return the body of the response rather than throwing an exception. A quick browse of the Jersey code showed a way around this: [source,Java] ---- private <T> T handle(Class<T> c, ClientRequest ro) throws UniformInterfaceException, ClientHandlerException { setProperties(ro); ClientResponse r = getHeadHandler().handle(ro); if (c == ClientResponse.class) return c.cast(r); if (r.getStatus() < 300) return r.getEntity(c); throw new UniformInterfaceException(r, ro.getPropertyAsFeature(ClientConfig.PROPERTY_BUFFER_RESPONSE_ENTITY_ON_EXCEPTION, true)); } ---- +++<cite>+++WebResource#handle+++</cite>+++ gets called by +++<cite>+++WebResource#get+++</cite>+++ and if we pass +++<cite>+++ClientResponse.class+++</cite>+++ to it instead of +++<cite>+++String.class+++</cite>+++ we can get around this because the code returns without checking the status of the response. Our code needs to read like this: [source,java] ---- public class HaSpike { public static void main(String[] args) { ClientResponse response = client() .resource("http://localhost:7474/db/manage/server/ha/slave") .accept(MediaType.TEXT_PLAIN) .get(ClientResponse.class); System.out.println("response = " + response.getEntity(String.class)); } ... } ---- And if we run it, this time we get the expected result: [source,text] ---- response = false ----

jersey-client-com-sun-jersey-api-client-uniforminterfaceexception

https://markhneedham.com/blog/2013/08/11/jersey-client-com-sun-jersey-api-client-uniforminterfaceexception

2013-08-11 07:23:31

neo4j: Extracting a subgraph as an adjacency matrix and calculating eigenvector centrality with JBLAS

Earlier in the week I wrote a blog post showing http://www.markhneedham.com/blog/2013/08/05/javajblas-calculating-eigenvector-centrality-of-an-adjacency-matrix/[how to calculate the eigenvector centrality of an adjacency matrix] using http://mikiobraun.github.io/jblas/[JBLAS] and the next step was to work out the eigenvector centrality of a neo4j sub graph. There were 3 steps involved in doing this: . Export the neo4j sub graph as an adjacency matrix . Run JBLAS over it to get eigenvector centrality scores for each node . Write those scores back into neo4j I decided to make use of the https://github.com/mneedham/revere/blob/neo4j/data/PaulRevereAppD.csv[Paul Revere data set] from http://kieranhealy.org/blog/archives/2013/06/09/using-metadata-to-find-paul-revere/[Kieran Healy's blog post] which consists of people and groups that they had membership of. The https://github.com/mneedham/revere/blob/neo4j/scripts/import.rb[script] to import the data is on https://github.com/mneedham/revere/tree/neo4j[my fork of the revere repository]. Having imported the data the next step was to write a cypher query which would give me the people in an http://en.wikipedia.org/wiki/Adjacency_matrix[adjacency matrix] with the number in each column/row intersection showing how many common groups that pair of people had. I thought it'd be easier to build this query incrementally so I started out writing a query which would return one row of the adjacency matrix: ~~~cypher MATCH p1:Person, p2:Person WHERE p1.name = "Paul Revere" WITH p1, p2 MATCH p = p1-[?:MEMBER_OF]\->()\<-[?:MEMBER_OF]-p2 WITH p1.name AS p1, p2.name AS p2, COUNT(p) AS links ORDER BY p2 RETURN p1, COLLECT(links) AS row ~~~ Here we start with Paul Revere and then find the relationships between him and every other person by way of a common group membership. We use an optional relationship since we need to include a value in each column/row of our adjacency matrix we need to return a 0 value for anyone he doesn't intersect with. If we run that query we get back the following: ~~~text +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | p1 | row | +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | "Paul Revere" | [2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,1,1,1,1,1,1,3,3,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,3,2,1,1,2,1,2,1,1,1,1,1,0,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,1,2,1,3,1,3,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,0,1,0,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,3,1,1,2,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,2,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,0,1,2,1,1,1,1,1,1,1] | +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ~~~ As it turns outs we've only got to remove the WHERE clause and order everybody and we've get the adjacency matrix for everyone: ~~~cypher MATCH p1:Person, p2:Person WITH p1, p2 MATCH p = p1-[?:MEMBER_OF]\->()\<-[?:MEMBER_OF]-p2 WITH p1.name AS p1, p2.name AS p2, COUNT(p) AS links ORDER BY p2 RETURN p1, COLLECT(links) AS row ORDER BY p1 ~~~ ~~~text +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | p1 | row | +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | "Abiel Ruddock" | [0,1,1,1,0,1,0,1,0,0,1,1,1,0,1,2,0,1,0,1,1,1,2,2,1,0,0,1,1,0,1,1,1,1,1,0,0,0,0,1,1,0,0,2,2,0,0,1,1,2,1,1,1,0,1,0,1,1,0,0,2,1,0,0,0,0,1,0,0,1,1,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,0,2,1,2,1,0,0,0,0,1,1,0,1,0,0,1,0,2,0,0,1,0,0,0,1,0,0,2,0,1,0,1,1,1,0,0,1,1,0,0,0,0,0,0,2,0,0,0,0,0,0,0,1,0,1,1,0,1,1,1,2,0,0,1,1,0,0,2,0,1,2,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,2,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,2,1,0,0,1,1,1,1,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,0,0,1,0,2,1,1,0,0,2,0,1,0,0,0,0,1,0,1,0,1,0,1,0] | | "Abraham Hunt" | [1,0,1,1,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,1,1,0,1,1,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,1,1,0,0,0,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0] | \... +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ 254 rows 9897 ms ~~~ The next step was to wire up the query results with the JBLAS code that I wrote in the previous post. I ended up with the https://github.com/mneedham/revere/blob/neo4j/src/main/java/Neo4jAdjacencyMatrixSpike.java[following]: ~~~java public class Neo4jAdjacencyMatrixSpike { public static void main(String[] args) throws SQLException { ClientResponse response = client() .resource("http://localhost:7474/db/data/cypher") .entity(queryAsJson(), MediaType.APPLICATION_JSON) .accept(MediaType.APPLICATION_JSON) .post(ClientResponse.class); JsonNode result = response.getEntity(JsonNode.class); ArrayNode rows = (ArrayNode) result.get("data"); List+++<Double>+++principalEigenvector = JBLASSpike.getPrincipalEigenvector(new DoubleMatrix(asMatrix(rows))); List+++<Person>+++people = asPeople(rows); updatePeopleWithEigenvector(people, principalEigenvector); System.out.println(sort(people).take(10)); } private static double[][] asMatrix(ArrayNode rows) { double[][] matrix = new double[rows.size()][254]; int rowCount = 0; for (JsonNode row : rows) { ArrayNode matrixRow = (ArrayNode) row.get(2); double[] rowInMatrix = new double[254]; matrix[rowCount] = rowInMatrix; int columnCount = 0; for (JsonNode jsonNode : matrixRow) { matrix[rowCount][columnCount] = jsonNode.asInt(); columnCount++; } rowCount++; } return matrix; } // rest cut for brevity } ~~~ Here we are taking the query and then converting it into an array of arrays before passing it to our JBLAS code to calculate the principal eigenvector. We then return the top 10 people: ~~~text Person{name='William Cooper', eigenvector=0.172604992239612, nodeId=68}, Person{name='Nathaniel Barber', eigenvector=0.17260499223961198, nodeId=18}, Person{name='John Hoffins', eigenvector=0.17260499223961195, nodeId=118}, Person{name='Paul Revere', eigenvector=0.17171142003936804, nodeId=207}, Person{name='Caleb Davis', eigenvector=0.16383970722169897, nodeId=71}, Person{name='Caleb Hopkins', eigenvector=0.16383970722169897, nodeId=121}, Person{name='Henry Bass', eigenvector=0.16383970722169897, nodeId=21}, Person{name='Thomas Chase', eigenvector=0.16383970722169897, nodeId=54}, Person{name='William Greenleaf', eigenvector=0.16383970722169897, nodeId=104}, Person{name='Edward Proctor', eigenvector=0.15600043886738055, nodeId=201} ~~~ I get back the same 10 people as Kieran Healy although they have different eigenvector values. As far as I understand the absolute value doesn't matter, what's more important is the relative score to other people so I think we're ok. The final step was to write these eigenvector values back into neo4j which we can do with the following code: ~~~java private static void updateNeo4jWithEigenvectors(List+++<Person>+++people) { for (Person person : people) { ObjectNode request = JsonNodeFactory.instance.objectNode(); request.put("query", "START p = node(\{nodeId}) SET p.eigenvectorCentrality=\{value}"); ObjectNode params = JsonNodeFactory.instance.objectNode(); params.put("nodeId", person.nodeId); params.put("value", person.eigenvector); request.put("params", params); client() .resource("http://localhost:7474/db/data/cypher") .entity(request, MediaType.APPLICATION_JSON) .accept(MediaType.APPLICATION_JSON) .post(ClientResponse.class); } } ~~~ Now we might use that eigenvector centrality value in other queries, such as one to show who the most central/potentially influential people are in each group: ~~~cypher MATCH g:Group\<-[:MEMBER_OF]-p WITH g.name AS group, p.name AS personName, p.eigenvectorCentrality as eigen ORDER BY eigen DESC WITH group, COLLECT(personName) AS people RETURN group, HEAD(people) + [HEAD(TAIL(people))] + [HEAD(TAIL(TAIL(people)))] AS mostCentral ~~~ ~~~text +--------------------------------------------------------------------------+ | group | mostCentral | +--------------------------------------------------------------------------+ | "StAndrewsLodge" | ["Paul Revere","Joseph Warren","Thomas Urann"] | | "BostonCommittee" | ["William Cooper","Nathaniel Barber","John Hoffins"] | | "LoyalNine" | ["Caleb Hopkins","William Greenleaf","Caleb Davis"] | | "LondonEnemies" | ["William Cooper","Nathaniel Barber","John Hoffins"] | | "LongRoomClub" | ["Paul Revere","John Hancock","Benjamin Clarke"] | | "NorthCaucus" | ["William Cooper","Nathaniel Barber","John Hoffins"] | | "TeaParty" | ["William Cooper","Nathaniel Barber","John Hoffins"] | +--------------------------------------------------------------------------+ 7 rows 280 ms ~~~ Our top ten feature frequently although it's interesting that only one of them is in the 'LongRoomClub' group which perhaps indicates that people in that group are less likely to be members of the other ones. I'd be interested if anyone can think of other potential uses for eigenvector centrality once we've got it back in the graph. All the code described in this post is https://github.com/mneedham/revere/tree/neo4j[on github] if you want to take it for a spin.+++</Person>++++++</Person>++++++</Double>+++

neo4j-extracting-a-subgraph-as-an-adjacency-matrix-and-calculating-eigenvector-centrality-with-jblas

https://markhneedham.com/blog/2013/08/11/neo4j-extracting-a-subgraph-as-an-adjacency-matrix-and-calculating-eigenvector-centrality-with-jblas

2013-08-17 21:13:27

BT Internet: Non existent hosts mapping to 92.242.132.15

We have a test in our code which checks for unresolvable hosts and it started failing for me because instead of throwing an UnknownHostException from the following call: [source,java] ---- InetAddress.getByName( "host.that.is.invalid" ) ---- I was getting back a valid although unreachable host. When I called ping it was easier to see what was going on: [source,bash] ---- $ ping host.that.is.invalid PING host.that.is.invalid (92.242.132.15): 56 data bytes Request timeout for icmp_seq 0 Request timeout for icmp_seq 1 Request timeout for icmp_seq 2 ---- As you can see, that hostname is resolving to '92.242.132.15' which I thought was a bit weird but dig confirmed that this was happening: [source,bash] ---- $ dig host.that.is.invalid ; <<>> DiG 9.8.3-P1 <<>> host.that.is.invalid ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 30043 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;host.that.is.invalid. IN A ;; ANSWER SECTION: host.that.is.invalid. 300 IN A 92.242.132.15 ---- It turns out that http://community.bt.com/t5/BB-Speed-Connection-Issues/DNS-oddity/td-p/49653[BT have plugged into DNS searches] and if one fails it redirects you to one of their pages instead - something I hadn't noticed before. The site they direct you to is www.webaddresshelp.bt.com which contains a list of sponsored results for the search term 'host.that.is.invalid' in this case. [source,bash] ---- $ ping www.webaddresshelp.bt.com PING www.webaddresshelp.bt.com (92.242.134.15): 56 data bytes ---- Luckily this can be disabled by going to link:[BT Web Address Help] and then choosing to http://preferences.webaddresshelp.bt.com/selfcare/preferences.cgi[disable BT Web Address Help]. If we then wait a little bit for our DNS cache to clear the ping works as expected: [source,bash] ---- $ ping host.that.is.invalid ping: cannot resolve host.that.is.invalid: Unknown host ----

bt-internet-non-existent-hosts-mapping-to-92-242-132-15

https://markhneedham.com/blog/2013/08/17/bt-internet-non-existent-hosts-mapping-to-92-242-132-15

2013-08-17 20:25:28

Jersey Client: java.net.ProtocolException: Server redirected too many times/Setting cookies on request

A couple of weeks ago I was trying to write a test around some OAuth code that we have on an internal application and I was using https://jersey.java.net/documentation/latest/user-guide.html#client[Jersey Client] to send the various requests. I initially started with the following code: [source,java] ---- Client = Client.create(); ClientResponse response = client.resource( "http://localhost:59680" ).get( ClientResponse.class ); ---- but when I ran the test I was getting the following exception: [source,text] ---- com.sun.jersey.api.client.ClientHandlerException: java.net.ProtocolException: Server redirected too many times (20) at com.sun.jersey.client.urlconnection.URLConnectionClientHandler.handle(URLConnectionClientHandler.java:151) at com.sun.jersey.api.client.Client.handle(Client.java:648) at com.sun.jersey.api.client.WebResource.handle(WebResource.java:680) at com.sun.jersey.api.client.WebResource.get(WebResource.java:191) at com.neotechnology.testlab.manager.webapp.AuthenticationIntegrationTest.shouldRedirectToGitHubForAuthentication(AuthenticationIntegrationTest.java:81) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at com.neotechnology.kirkaldy.testing.Resources$1.evaluate(Resources.java:84) at com.neotechnology.kirkaldy.testing.FailureOutput$2.evaluate(FailureOutput.java:37) at org.junit.rules.RunRules.evaluate(RunRules.java:18) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222) at org.junit.runners.ParentRunner.run(ParentRunner.java:300) at org.junit.runner.JUnitCore.run(JUnitCore.java:157) at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:63) Caused by: java.net.ProtocolException: Server redirected too many times (20) at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1446) at java.net.HttpURLConnection.getResponseCode(HttpURLConnection.java:379) at com.sun.jersey.client.urlconnection.URLConnectionClientHandler._invoke(URLConnectionClientHandler.java:249) at com.sun.jersey.client.urlconnection.URLConnectionClientHandler.handle(URLConnectionClientHandler.java:149) ... 28 more ---- If we check the traffic going across port 59680 we can see what's going wrong: [source,text] ---- $ sudo ngrep -d lo0 port 59680 interface: lo0 (127.0.0.0/255.0.0.0) filter: (ip) and ( port 59680 ) ##### T 127.0.0.1:59704 -> 127.0.0.1:59680 [AP] GET / HTTP/1.1..User-Agent: Java/1.6.0_45..Host: localhost:59680..Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2..Connection: keep-alive.... ## T 127.0.0.1:59680 -> 127.0.0.1:59704 [AP] HTTP/1.1 302 Found..Set-Cookie: JSESSIONID=mdyw3a4fmqc1b6p53birm4dd;Path=/..Expires: Thu, 01 Jan 1970 00:00:00 GMT..Location: http://localhost:59679/authorize?client_id=basic-client&state=the-state&scope=user%2Crepo..Content-Length : 0..Server: Jetty(8.1.8.v20121106).... ########### T 127.0.0.1:59707 -> 127.0.0.1:59680 [AP] GET /auth/callback?code=timey-wimey&state=the-state HTTP/1.1..User-Agent: Java/1.6.0_45..Host: localhost:59680..Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2..Connection: keep-alive.... ## T 127.0.0.1:59680 -> 127.0.0.1:59707 [AP] HTTP/1.1 302 Found..Cache-Control: no-cache..Set-Cookie: JSESSIONID=8gggez0ns9ftiex4314mbgz9;Path=/..Expires: Thu, 01 Jan 1970 00:00:00 GMT..Location: http://localhost:59680/..Content-Length: 0..Server: Jetty(8.1.8.v20121106).... ########### T 127.0.0.1:59713 -> 127.0.0.1:59680 [AP] GET / HTTP/1.1..User-Agent: Java/1.6.0_45..Host: localhost:59680..Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2..Connection: keep-alive.... ## ---- The response we receive includes a direction to the client to store a cookie but we can see on the next request that the cookie hasn't been included. I came across http://stackoverflow.com/questions/6713893/jersey-client-adding-cookies-to-request[this post which had a few suggestions on how to get around the problem] but the only approach that worked for me was to use jersey-apache-client for which I added the following dependency: [source,xml] ---- <dependency> <groupId>com.sun.jersey.contribs</groupId> <artifactId>jersey-apache-client</artifactId> <version>1.13</version> <type>jar</type> </dependency> ---- I then change my client code to read like this: [source,java] ---- ApacheHttpClientConfig config = new DefaultApacheHttpClientConfig(); config.getProperties().put(ApacheHttpClientConfig.PROPERTY_HANDLE_COOKIES, true); ApacheHttpClient client = ApacheHttpClient.create( config ); client.setFollowRedirects(true); client.getClientHandler().getHttpClient().getParams().setBooleanParameter( HttpClientParams.ALLOW_CIRCULAR_REDIRECTS, true ); ClientResponse response = client.resource( "http://localhost:59680" ).get( ClientResponse.class ); ---- If we run that and watch the output using ngrep we can see that it now handles cookies correctly: [source,text] ---- $ sudo ngrep -d lo0 port 59680 Password: interface: lo0 (127.0.0.0/255.0.0.0) filter: (ip) and ( port 59680 ) ##### T 127.0.0.1:60372 -> 127.0.0.1:59680 [AP] GET / HTTP/1.1..User-Agent: Jakarta Commons-HttpClient/3.1..Host: localhost:59680.... ## T 127.0.0.1:59680 -> 127.0.0.1:60372 [AP] HTTP/1.1 302 Found..Set-Cookie: JSESSIONID=vn8zzf9ep3x4mtw66ydm0n6a;Path=/..Expires: Thu, 01 Jan 1970 00:00:00 GMT..Location: http://localhost:60322/authorize?client_id=basic-client&state=the-state&scope=user%2Crepo..Content-Length : 0..Server: Jetty(8.1.8.v20121106).... ## T 127.0.0.1:60372 -> 127.0.0.1:59680 [AP] GET /auth/callback?code=timey-wimey&state=the-state HTTP/1.1..User-Agent: Jakarta Commons-HttpClient/3.1..Host: localhost:59680..Cookie: $Version=0; JSESSIONID=vn8zzf9ep3x4mtw66ydm0n6a; $Path=/.... ## T 127.0.0.1:59680 -> 127.0.0.1:60372 [AP] HTTP/1.1 302 Found..Cache-Control: no-cache..Location: http://localhost:59680/..Content-Length: 0..Server: Jetty(8.1.8.v20121106).... ## T 127.0.0.1:60372 -> 127.0.0.1:59680 [AP] GET / HTTP/1.1..User-Agent: Jakarta Commons-HttpClient/3.1..Host: localhost:59680..Cookie: $Version=0; JSESSIONID=vn8zzf9ep3x4mtw66ydm0n6a; $Path=/.... ## T 127.0.0.1:59680 -> 127.0.0.1:60372 [AP] HTTP/1.1 200 OK..Vary: Accept-Encoding..Accept-Ranges: bytes..Content-Type: text/html..Content-Length: 2439..Last-Modified: Tue, 23 Jul 2013 10:48:15 GMT..Server: Jetty(8.1.8.v20121106)....<!DOCTYPE html>.<html>.<head>. <title>Tes t Lab</title>. <meta name="viewport" content="width=device-width initial-scale=1.0 maximum-scale=1.0 user-scalable=0"/>. <link rel="stylesheet" type="text/css" href="css/bootstrap.css">. <link rel="stylesheet" type="text/css" hr ef="css/bootstrap-responsive.css">. <link rel="stylesheet" type="text/css" href="css/test-lab.css">. <link rel="icon" type="image/png" href="images/testlab-16.png">. <script src="js/require.js"></script>. <script src="js/d3.v3. js" charset="UTF-8"></script>. <script src="js/jquery-1.8.3.min.js"></script>. <script src="js/bootstrap.js"></script>. <script src="js/test-lab.js"></script>. <script type="text/javascript" src="js/google-analytics.js"></scrip t>.</head>.<body>..<a href="navbar.html" class="inline-replacement"></a>..<div class="container">.. <h1 class="title">Neo Technology Test Lab</h1>.. <div class="dev-mode">Viewing dev-mode</div>.. <h2>Benchmark Series Results</h2 >.. <table id="benchmarkseries_list" class="table">. <thead></thead>. <tbody></tbody>. </table>.. <a href="new-benchmark-series.html" class="btn load-modal"><i class="icon-plus"></i> Create Benchmark Series...</a>.. <h2>T ests</h2>.. <table id="test_list" class="table">. <thead></thead>. <tbody></tbody>. </table>.. <a href="run-test.html" class="btn load-modal"><i class="icon-plus"></i> Run Test...</a>. <a href="run-benchmark.html" class=" btn load-modal"><i class="icon-plus"></i> Run Benchmark...</a>.. <h2>Clusters</h2>.. <table id="cluster_list" class="table"></table>.. <a href="new-database-cluster.html" class="btn load-modal"><i class="icon-plus"></i> New Data base Cluster...</a>. <a href="new-load-generation-cluster.html" class="btn load-modal"><i class="icon-plus"></i> New Load Generation Cluster...</a>.. <h2>Datasets</h2>.. <table id="dataset_list" class="table">. <thead></thead >. <tbody></tbody>. </table>.. <a href="new-dataset.html" class="btn load-modal"><i class="icon-plus"></i> Create New Dataset...</a>.. <a href="confirm.html" class="inline-replacement"></a>..</div>..<script type="text/javascr ipt">. (function (). {. window.setInterval( function (). {. d3.json( "/public/authenticated", function ( status ). {. if ( !status.authenticated ). {. window.location.reload();. }. } );. }, 5000 );. kirkaldy.initializeUI();. })();.</script>..</body>.</html>. ----

jersey-client-java-net-protocolexception-server-redirected-too-many-timessetting-cookies-on-request

https://markhneedham.com/blog/2013/08/17/jersey-client-java-net-protocolexception-server-redirected-too-many-timessetting-cookies-on-request

2013-08-19 23:13:04

Coding: Hack then revert

For a long while my default approach when I came across a new code base that I wanted to change was to read all the code and try and understand how it all fitted together by sketching out flow of control diagrams. Only after I'd done that would I start planning how I could make my changes. This works reasonably well but it's quite time consuming and a couple of years ago a former colleague (I can't remember who!) showed me another technique which seems to be more effective. Rather than trying to understand how all the code fits together we briefly skim it to get a general understanding but don't drill into the specifics. Instead once we've got a general understanding we make changes to the code and then either run the application or run the tests to see if it works as we expected. There'll often be a couple of cycles before we understand exactly what changes we need to make and I've found that *reverting the code after each attempt* works quite well. When we change the same bit of code for the 2nd/3rd/4th time it takes a fraction of the time it did on the 1st occasion and we'll often spot improvements that we can make which we didn't notice before. I'd recommend this as an exploratory tool if you haven't already tried it and as an added bonus it's much more fun than statically analysing code and trying to figure out how it's mean to work!

coding-hack-then-revert

https://markhneedham.com/blog/2013/08/19/coding-hack-then-revert

2013-08-26 17:58:58

Clojure/Enlive: Screen scraping a HTML file from disk

I wanted to play around with some Champions League data and I came across the http://www.rsssf.com/ec/[Rec Sport Soccer Statistics Foundation] which has collected results of all matches since the tournament started in 1955. I wanted to get a list of all the matches for a specific season so I started out by downloading the file: [source,bash] ---- $ pwd /tmp/football $ wget http://www.rsssf.com/ec/ec200203det.html ---- The next step was to load that page and then run a CSS selector over it to extract the matches. In Ruby land I usually use http://nokogiri.org/[nokogiri] or http://rubygems.org/gems/selenium-webdriver[Web Driver] to do this but I'd heard that Clojure's https://github.com/cgrand/enlive[enlive] is good for this type of work so I thought I'd give it a try. I found a https://gist.github.com/AlexBaranosky/782367[couple] http://clj-me.cgrand.net/2009/04/27/screenscraping-with-enlive/[of examples] showing how to get started but they both seemed to rely on the web page being at a HTTP URI rather than on disk. I eventually spotted an example which http://stackoverflow.com/questions/11094837/is-there-a-parser-for-html-to-hiccup-structures[passed in HTML as a string] to +++<cite>+++html-resource+++</cite>+++ and decided to load the contents of my file as a string and then pass that in: [source,lisp] ---- (ns ranking-algorithms.parse (:use [net.cgrand.enlive-html])) (defn fetch-page [file-path] (html-resource (java.io.StringReader. (slurp file-path)))) ---- The next step was to take that page representation and extract the matches. Since the page isn't particularly well laid out for that purpose I ended up writing a regular expression to find the matching parts: [source,lisp] ---- (defn matches [file] (->> file fetch-page extract-rows (map extract-content) (filter recognise-match?))) (defn extract-rows [page] (select page [:div.Section1 :p :span])) (defn extract-content [row] (first (get row :content))) (defn recognise-match? [row] (and (string? row) (re-matches #"[a-zA-Z\s]+-[a-zA-Z\s]+ [0-9][\s]?.[\s]?[0-9]" row))) ---- The interesting part is +++<cite>+++extract-rows+++</cite>+++ where we apply the CSS selector 'div.Section1 p span', the only difference being that we prefix the selector with ':'. We then filter everything through +++<cite>+++recgonise-match?+++</cite>+++ to find the matches since almost every row of the page is returned by our CSS selector. Unfortunately I don't think there is a more specific selector that I could have used. When I execute that function I ended up with the following output: [source,text] ---- > (matches "/tmp/football/ec200203det.html") ( ... "Lokomotiv\nMoskou-Borussia Dortmund 1 - 2" "Borussia\nDortmund-AC Milan 0 - 1" "Real\nMadrid-Lokomotiv Moskou 2 - 2" "Real\nMadrid-Borussia Dortmund 2 - 1" "AC Milan-Lokomotiv\nMoskou 1 - 0" "Borussia Dortmund-Real\nMadrid 1 - 1" "Lokomotiv\nMoskou-AC Milan 0 - 1" ... ) ---- The next step was to split out the strings into a structure that I can use in a rankings algorithm so I applied another function to each string to pull out the appropriate parts: [source,lisp] ---- (defn matches [file] (->> file fetch-page extract-rows (map extract-content) (filter recognise-match?) (map as-match))) (defn cleanup [word] (clojure.string/replace word "\n" " ")) (defn as-match [row] (let [match (first (re-seq #"([a-zA-Z\s]+)-([a-zA-Z\s]+) ([0-9])[\s]?.[\s]?([0-9])" row))] {:home (cleanup (nth match 1)) :away (cleanup (nth match 2)) :home_score (nth match 3) :away_score (nth match 4)})) ---- If we run the function now we get a much nicer output to play with: [source,text] ---- > (matches "/tmp/football/ec200203det.html") ( ... {:home "AC Milan", :away "Internazionale Milaan", :home_score "0", :away_score "0"} {:home "Juventus Turijn", :away "Real Madrid", :home_score "3", :away_score "1"} {:home "Internazionale Milaan", :away "AC Milan", :home_score "1", :away_score "1"} ) ----

clojureenlive-screen-scraping-a-html-file-from-disk

https://markhneedham.com/blog/2013/08/26/clojureenlive-screen-scraping-a-html-file-from-disk

2013-08-31 10:52:14

Neo4j's Graph Café London - 28th August 2013

On Wednesday evening I attended an interesting spin on the monthly Neo4j meetup, where instead of the usual 'talk then go to the pub afterwards' format my colleagues https://twitter.com/rvanbruggen[Rik] and https://twitter.com/arturasver[Arturas] organised http://www.meetup.com/graphdb-london/events/123869482/[Graph Café] in the Doggetts Coat and Badge pub in Blackfriars. The format was changed as well - the evening consisted of ~10 lightening talks which were spread out over about 3 hours, an approach Rik has used at http://blog.neo4j.org/2013/05/graph-cafes-starting-in-belgium-and.html[similar events] in Belgium and Holland earlier in the year. In the gaps in between the talks people mingled with each other and shared tips/talked through the problems they were trying to solve using graphs. There was a strong turn out and it was *much more interactive than a normal meet-up* where the main interaction comes from people asking the speaker questions. While there is a pub afterwards there's always a noticeable drop out from the talk so it was good to have everyone together chatting this time. https://twitter.com/fgibson/status/372751710550106112[Frank Gibson] described what I thought was the coolest use of graphs of the evening. He's modelling different drugs, which medical conditions they treat and which other drugs they aren't compatible with. The next step is to bring that together with patients' medical records to help doctors make treatment recommendations. As well as the talks, table clothes were laid out on the tables where people could sketch out the problems they were working on and get input from others. https://twitter.com/thobe[Tobias] went a bit meta and drew a graph about graph databases: image::{{<siteurl>}}/uploads/2013/08/neograph.jpg[Neograph,600] While it's often said that graphs are http://www.slideshare.net/slideshow/embed_code/12275060?startSlide=19[whiteboard friendly] I was still surprised at how effective this was. When someone was explaining what they were working on I found myself sketching out what I'd interpreted and then they'd join in and point out bits I'd misunderstood and bits they were thinking about changing. Along those lines, my colleague http://www.apcjones.com/[Alistair] also demoed http://www.apcjones.com/arrows/[Arrows] - a Javascript library for drawing graphs which I use for most of the graph related diagrams on here. image::{{<siteurl>}}/uploads/2013/08/outside.jpg[Outside,600] Overall it was a fun meet up and now we need to try and work out how to keep the interactive aspect when it isn't 25 degrees outside and we're not in a pub overlooking http://www.stpauls.co.uk/[St Paul's]. Rik has put up https://plus.google.com/photos/112536463589645792207/albums/5917315641597676929?banner=pwa[a slide show of pictures] from the event and if you're interested in hosting your own similar event you should probably https://twitter.com/rvanbruggen[ping Rik] for some tips!

neo4js-graph-cafe-london-28th-august-2013

https://markhneedham.com/blog/2013/08/31/neo4js-graph-cafe-london-28th-august-2013

2013-08-31 13:01:16

Elo Rating System: Ranking Champions League teams using Clojure

As I mentioned in an earlier blog post http://www.markhneedham.com/blog/2013/08/24/ranking-systems-what-ive-learnt-so-far/[I've been learning about ranking systems] and one of the first ones I came across was the http://en.wikipedia.org/wiki/Elo_rating_system[Elo rating system] which is most famously used to rank chess players. The Elo rating system uses the following formula to work out a player/team's ranking after they've participated in a match: ____ R' = R + K * (S - E) * R' is the new rating * R is the old rating * K is a maximum value for increase or decrease of rating (16 or 32 for ELO) * S is the score for a game * E is the expected score for a game + I converted that formula into the following Clojure functions: + which would be called like this to work out the new ranking of a team ranked 1200 that beat a team ranked 1500: + The way it works is that we first work out the likelihood that we should win the match by calling +++<cite>+++expected+++</cite>+++: + This tells us that we have a 15% chance of winning the match so if we do win then our ranking should be increased by a large amount as we aren't expected to win. In this case a win gives us a points increase of '32 * (1-0.15)' which is ~27 points. + I kept things simple by always setting the importance/maximum value of increase or decrease to 32. The http://www.eloratings.net/system.html[World Football Rankings] took a different approach where they vary it based on the importance of a match and the margin of victory. + I decided to try out the algorithm on the 2002/2003 Champions League season. I was able to http://www.rsssf.com/ec/ec200203det.html[grab the data] from The Rec Sport Soccer Statistics Foundation and I've written previously about http://www.markhneedham.com/blog/2013/08/26/clojureenlive-screen-scraping-a-html-file-from-disk/[how I scraped it using Enlive]. + With a lot of help from https://twitter.com/pbostrom[Paul Bostrom] I ended up with the following code to run a reduce over the matches while updating team rankings after each match: + The +++<cite>+++matches+++</cite>+++ parameter that we pass into +++<cite>+++top-teams+++</cite>+++ https://github.com/mneedham/ranking-algorithms/blob/master/src/ranking_algorithms/parse.clj#L20[looks like this]: + And calling +++<cite>+++https://github.com/mneedham/ranking-algorithms/blob/master/src/ranking_algorithms/parse.clj#L22[extract-teams]+++</cite>+++ on it gets us a set of all the teams involved: + We then +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/mapcat[mapcat]+++</cite>+++ over it to get a vector containing team/default points pairs: + before calling +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/array-map[array-map]+++</cite>+++ to make a hash of the result: + We then apply a reduce over all the matches and call the function +++<cite>+++process-match+++</cite>+++ on each iteration to update team rankings appropriately. The final step is to sort the teams by their ranking so we can list the top teams: + Interestingly the winners (Juventus) are only in 5th place and the top 2 places are occupied by teams that lost in the Quarter Final. I wrote the following functions to investigate what was going on: + If we call it with Juventus we can see how they performed in their matches: + Although I'm missing the final - I need to fix the parser to pick that match up and it was a draw anyway - they actually only won 8 of their matches outright. Barcelona, on the other hand, won 13 matches although 2 of those were qualifiers. + The next step is to take into account the importance of the match rather than applying an importance of 32 across the board and adding some value to winning a tie/match even if it's on penalties or away goals. + The https://github.com/mneedham/ranking-algorithms/tree/master/src/ranking_algorithms[code is on github] if you want to play around with it or have suggestions for something else I can try out. ____

elo-rating-system-ranking-champions-league-teams-using-clojure

https://markhneedham.com/blog/2013/08/31/elo-rating-system-ranking-champions-league-teams-using-clojure

2013-08-30 12:23:21

Clojure: Handling state by updating a vector inside an atom

As I mentioned in a http://www.markhneedham.com/blog/2013/08/24/ranking-systems-what-ive-learnt-so-far/[previous blog post], I've been learning about ranking algorithms and I wanted to apply them to a series of football matches to see who the strongest team was. Before that, however, I wanted to sketch out the functions that I'd need to do this and I started with the following collections of matches and team rankings: [source,lisp] ---- (def m [{:home "Manchester United", :away "Manchester City", :home_score 1, :away_score 0} {:home "Manchester United", :away "Manchester City", :home_score 2, :away_score 0}]) (def teams [ {:name "Manchester United" :points 1200} {:name "Manchester City" :points 1200} ]) ---- I wanted to iterate over the matches and make the appropriate updates to the teams' rankings depending on the result of the match. If a team wins their ranking goes up and if they lose it goes down. I wasn't sure how to iterate over the matches and pass along an updated teams collection so I decided to wrap teams in an http://clojuredocs.org/clojure_core/1.2.0/clojure.core/atom[atom] that I could update: [source,lisp] ---- (def t (atom teams)) ---- The next step was to work out how to update the vector inside the atom +++<cite>+++t+++</cite>+++. The +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/assoc[assoc]+++</cite>+++ function comes in useful here. If we want to update the ranking for Manchester United we could write the following code: [source,lisp] ---- > (map #(if (= "Manchester United" (:name %)) (assoc % :points 1500) %) teams) [{:name "Manchester United", :points 1500} {:name "Manchester City", :points 1200}] ---- We're mapping over the collection of teams and then each time checking whether or not the team is Manchester United. If it is then we update the ':points' value and if not then we leave it alone. The next step is to update the vector that the atom +++<cite>+++t+++</cite>+++ references which we can do by using the +++<cite>+++swap!+++</cite>+++ function: [source,lisp] ---- > (swap! t (fn [teams] (map #(if (= "Manchester United" (:name %)) (assoc % :points 1500) %) teams))) ({:name "Manchester United", :points 1500} {:name "Manchester City", :points 1200}) ---- If we look inside +++<cite>+++t+++</cite>+++ we can see that its reference has changed as well:~~~ ~~~lisp > @t [{:name "Manchester United", :points 1500} {:name "Manchester City", :points 1200}] ~~~ Our next step is to pull this code into a function that we can call from other code since we'll eventually want to iterate over the matches and update teams appropriately. Since we know that we'll need to update both the home and away team after each match we'll make sure the function can handle that: ~~~lisp (defn update-teams [teams team1 new-score1 team2 new-score2] (vec (map #(cond (= team1 (:name %)) (assoc % :points new-score1) (= team2 (:name %)) (assoc % :points new-score2) :else %) teams))) ~~~ We're calling +++<cite>+++vec+++</cite>+++ on the result to get back to a vector like we had initially. We'll handle the updating of the atom reference from elsewhere, this function only handles creating a new instance of the underlying vector. Now let's call that function while we're iterating over the matches that we defined earlier: ~~~lisp > (map (fn [match] (swap! t (fn [teams] (update-teams teams (:home match) (new-home-score match teams) (:away match) (new-away-score match teams))))) m) ([{:name "Manchester United", :points 1201} {:name "Manchester City", :points 1201}] [{:name "Manchester United", :points 1202} {:name "Manchester City", :points 1202}]) ~~~ In this case I've stubbed out +++<cite>+++new-home-score+++</cite>+++ and +++<cite>+++new-away-score+++</cite>+++ to increment the existing ranking by one: ~~~lisp (defn new-home-score [match teams] (let [home-team (find-team (:home match) teams)] (inc (:points home-team)))) (defn new-away-score [match teams] (let [away-team (find-team (:away match) teams)] (inc (:points away-team)))) (defn find-team [team teams] (first (filter #(= team (:name %)) teams))) ~~~ If we were using a real algorithm we'd assign points to the winner and take them away from the loser of a match. Although the map over the matches actually returns a collection showing the updated rankings after each match, if we want to access the current rankings we'd deference the atom +++<cite>+++t+++</cite>+++ like we did earlier: ~~~lisp > @t [{:name "Manchester United", :points 1202} {:name "Manchester City", :points 1202}] ~~~ This approach works but it feels a bit hacky to have resorted to using an atom so I'd be interested in hearing from any Clojure experts if there's a better way to solve this type of problem and if so what it is.

clojure-handling-state-by-updating-a-vector-inside-an-atom

https://markhneedham.com/blog/2013/08/30/clojure-handling-state-by-updating-a-vector-inside-an-atom

2013-08-24 11:05:58

Ranking Systems: What I've learnt so far

I often go off on massive tangents reading all about a new topic but don't record what I've read so if I go back to the topic again in the future I have to start from scratch which is quite frustrating. In this instance after playing around with http://www.markhneedham.com/blog/2013/08/11/neo4j-extracting-a-subgraph-as-an-adjacency-matrix-and-calculating-eigenvector-centrality-with-jblas/[calculating the] http://www.markhneedham.com/blog/2013/08/05/javajblas-calculating-eigenvector-centrality-of-an-adjacency-matrix/[eigenvector centrality] of a sub graph I learnt that this algorithm can also be used in ranking systems. I started off by reading a paper written by James Keener about the https://umdrive.memphis.edu/ccrousse/public/MATH%207375/PERRON.pdf[Perron-Frobenius Theorem and the ranking of American football teams]. The http://en.wikipedia.org/wiki/Perron%E2%80%93Frobenius_theorem[Perron-Frobenius Theorem] asserts the following: ____ a real square matrix with positive entries has a unique largest real eigenvalue and that the corresponding eigenvector has strictly positive components ____ This is applicable for *network based ranking systems* as we can build up a matrix of teams, store a value representing their performance against each other, and then calculate an ordered ranking based on eigenvector centrality. I also came across the following articles describing different network-based approaches to ranking teams/players in tennis and basketball respectively: * http://www.nature.com/srep/2012/121205/srep00904/full/srep00904.html[A network-based dynamical ranking system for competitive sports] * http://blog.biophysengr.net/2012/03/eigenbracket-2012-using-graph-theory-to.html[Using Graph Theory to Predict NCAA March Madness Basketball] Unfortunately I haven't come across any corresponding code showing how to implement those algorithms so I need to do a bit more reading and figure out how to do it. In the world of non network based ranking systems I came across 3 algorithms: * http://en.wikipedia.org/wiki/ELO_rating_system[Elo] - this is a method originally developed to calculate the relative skill of chess players. Players start out with an average rating which then increases/decreases based on games they take part in. If they beat someone much more highly ranked then they'd gain a lot of points whereas losing to someone similarly ranked wouldn't affect their ranking too much. I came across a version used to rank http://www.eloratings.net/system.html[country football teams]. and the algorithm is quite well described in Christopher Allen's article on http://www.lifewithalacrity.com/2006/01/ranking_systems.html[competitive ranking systems]. * http://math.bu.edu/people/mg/research/gdescrip.pdf[Glicko] - this method was developed as the author, Mark Glickman, detected some flaws in the Elo rating system around the reliability of players' ratings. This algorithm therefore introduces the concept of a ratings deviation (RD) to measure uncertainty in a rating. If a player player plays regularly they'd have a low RD and if they don't it'd be higher. This is then taken into account when assigning points based on games between different players. Rob Kohr has an implementation of this one using https://github.com/RobKohr/glicko[Javascript on his github]. * http://research.microsoft.com/en-us/projects/trueskill/[TrueSkill] - this one was developed by Microsoft Research to rank players using XBox Live. This seems similar to Glicko in that it has a rating and uncertainty for each player. http://research.microsoft.com/en-us/projects/trueskill/faq.aspx[TrueSkill's FAQs] suggest the following difference between the two: + ____ Glicko was developed as an extension of ELO and was thus naturally limited to two player matches which end in either win or loss. Glicko cannot update skill levels of players if they compete in multi-player events or even in teams. The logistic model would make it computationally expensive to deal with team and multi-player games. Moreover, chess is usually played in pre-set tournaments and thus matching the right opponents was not considered a relevant problem in Glicko. In contrast, the TrueSkill ranking system offers a way to measure the quality of a match between any set of players. ____ Scott Hamilton has https://github.com/McLeopold/PythonSkills[an implementation of all these algorithms in Python] which I need to play around with. He based his algorithms on a blog post written by http://www.moserware.com/2010/03/computing-your-skill.html[Jeff Moser] in which he explains probabilities, the Gaussian distribution, Bayesian probability and factor graphs in deciphering the TrueSkill algorithm. Moser's created https://github.com/moserware/Skills[a project implementing TrueSkill in C#] on github. I follow tennis and football reasonably closely so I thought I'd do a bit of reading about the main two rankings I know about there as well: * http://www.uefa.com/memberassociations/uefarankings/club/index.html[UEFA club coefficients] - used to rank football clubs that have taken part in a European competition over the last 5 seasons. It takes into account the importance of the match but not the strength of the opposition * http://www.atpworldtour.com/rankings/rankings-faq.aspx[ATP Tennis Rankings] - used to rank tennis players on a rolling basis over the last 12 months. They take into account the importance of a tournament and the round a player reached to assign ranking points. Now that I've recorded all that it's time to go and play with some of them!

ranking-systems-what-ive-learnt-so-far

https://markhneedham.com/blog/2013/08/24/ranking-systems-what-ive-learnt-so-far

2013-08-13 22:59:52

Python: for/list comprehensions and dictionaries

I've been working through Coursera's https://class.coursera.org/matrix-001/class/index[Linear Algebra course] and since all of the exercises are in Python I've been playing around with it again. One interesting thing I learnt is that you can construct dictionaries using a http://www.secnetix.de/olli/Python/list_comprehensions.hawk[list comprehension] type syntax. For example, if we start with the following dictionaries: [source,python] ---- >>> x = { "a": 1, "b":2 } >>> y = {1: "mark", 2: "will"} >>> x {'a': 1, 'b': 2} >>> y {1: 'mark', 2: 'will'} ---- We might want to create a new dictionary which links from the keys in x to the values in y. In this case we work out the mapping by finding the key in y which corresponds with each value in x. So the map we want to see at the end should look like this: [source,text] ---- {"a": 'mark', "b": 'will'} ---- We can iterate over the keys/values of a dictionary by calling +++<cite>+++Dictionary#iteritems+++</cite>+++ like so: [source,python] ---- >>> for key, value in x.iteritems(): ... print (key, value) ... ('a', 1) ('b', 2) ---- I thought I might be able to construct my new dictionary by converting this into a for comprehension: [source,python] ---- >>> [key:value for key, value in x.iteritems()] File "<stdin>", line 1 [key:value for key, value in x.iteritems()] ^ SyntaxError: invalid syntax ---- Unfortunately that didn't work but I came across http://stackoverflow.com/questions/3294889/iterating-over-dictionaries-for-loops-in-python[an interesting post] from which I learned that using curly brackets might do the trick. [source,python] ---- >>> {key:value for key, value in x.iteritems()} {'a': 1, 'b': 2} >>> type({key:value for key, value in x.iteritems()}) <type 'dict'> ---- I wanted to make the final dictionary take a lookup into account which we can do like this: [source,python] ---- >>> {key:y[value] for key, value in x.iteritems()} {'a': 'mark', 'b': 'will'} ---- Apparently this is known as a http://www.python.org/dev/peps/pep-0274/[dictionary comprehension] and has http://stackoverflow.com/questions/7276511/are-there-dictionary-comprehensions-in-python-problem-with-function-returning[been in the language since version 2.7]. I'm sure this is old news to seasoned Python developers but I'd not come across it before so to me it's pretty neat!

python-forlist-comprehensions-and-dictionaries

https://markhneedham.com/blog/2013/08/13/python-forlist-comprehensions-and-dictionaries

2013-08-13 20:00:45

9 algorithms that changed the future - John MacCormick: Book Review

== The Book http://www.amazon.co.uk/Nine-Algorithms-That-Changed-Future/dp/0691158193/ref=sr_1_1?ie=UTF8&qid=1376332180&sr=8-1&keywords=9+algorithms+that+changed+the+future[9 algorithms that changed the future (the ingenious ideas that drive today's computers)] by John MacCormick == My Thoughts I came across this book while idly browsing http://www.foyles.co.uk/[a book store] and since I've found most introduction to algorithms books very dry I thought it'd be interesting to see what one aimed at the general public would be like. Overall it was an enjoyable read and I quite like the pattern that the author used for each algorithm, which was: * Describe the problem that it's needed for. * Explain a simplified version of the algorithm or use a metaphor to give the general outline. * Explain which bits were simplified and how the real version addresses those simplifications. The first step is often missed out in algorithms books which is a mistake for people like me who become more interested in a subject once a practical use case is explained. Although the title claims 9 algorithms I counted the following 8 which made the cut: * http://en.wikipedia.org/wiki/Search_engine_indexing[Search Engine Indexing] - this chapter covers how you'd go about writing the part of a search engine which works out which pages are applicable for certain search terms. It effectively describes http://lucene.apache.org/core/[Lucene]. * http://en.wikipedia.org/wiki/PageRank[Page Rank] - this chapter described Google's PageRank which was particularly timely for me as I've recently been http://www.markhneedham.com/blog/2013/08/05/javajblas-calculating-eigenvector-centrality-of-an-adjacency-matrix/[playing around with some similar algorithms]. The author works step by step through the algorithm using a simple example covering it very throughly. The best thing I've seen on the web is http://williamcotton.com/pagerank-explained-with-javascript[PageRank explained with Javascript] although that is slightly more technical than the book. I didn't realise that Sergey Brin and Larry Page had published a paper back in 1998 titled 'http://infolab.stanford.edu/~backrub/google.html[The Anatomy of a Large-Scale Hypertextual Web Search Engine]' which explains the initial PageRank algorithm in more detail. * http://en.wikipedia.org/wiki/Public-key_cryptography[Public Key Cryptography] - this chapter mostly covers http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange[Diffie-Hellman key exchange] which I realise is quite well explained on wikipedia as well. * http://en.wikipedia.org/wiki/Error_detection_and_correction[Error-Correcting Codes] - I took the http://en.wikipedia.org/wiki/Checksum[checksums] included in somewhat for granted but in this chapter MacCormick goes through the problem of data getting lost or corrupted in transfer and iterates through potential solutions. The further reading from this chapter is 'http://cm.bell-labs.com/cm/ms/what/shannonday/shannon1948.pdf[A Mathematical Theory of Communication]', http://en.wikipedia.org/wiki/Hamming_code[Hamming code] and http://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction[Reed-Solomon error correction]. * http://en.wikipedia.org/wiki/Pattern_recognition[Pattern Recognition] - this chapter covered a variety of machine learning algorithms initially focusing on digit recognition - something that Jen Smith and I spent http://www.markhneedham.com/blog/tag/kaggle/[a chunk of time working on last year for the Kaggle problem]. The three algorithms covered are http://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm[nearest neighbours], http://en.wikipedia.org/wiki/Decision_tree[decision trees] and http://en.wikipedia.org/wiki/Artificial_neural_network[neural networks], all of which we attempted! I recently came across the concept of http://deeplearning.net/tutorial/lenet.html[convolutional neural networks and deep learning] which I've yet to try out but are apparently even more accurate than plain neural networks. * http://en.wikipedia.org/wiki/Data_compression[Data Compression] - I imagine data compression would be one of the more familiar algorithms on this list since everybody knows how to 'zip up a file' and send it around. The author covers lossy algorithms such as 'http://bitdepth.thomasrutter.com/2010/02/02/how-jpeg-and-mpeg-picture-compression-algorithms-work/[JPEG Leave it Out]' which reduces image quality as well as size, as well as lossless algorithms such as http://en.wikipedia.org/wiki/LZ77_and_LZ78[LZ77], http://en.wikipedia.org/wiki/Shannon%E2%80%93Fano_coding[Shannon-Fano coding] and http://en.wikipedia.org/wiki/Huffman_coding[Huffman coding]. The latter is covered in https://class.coursera.org/algo2-2012-001/lecture/preview[Stanford's Algorithms II] and I think the explanation there is actually easier to understand than the book's. * http://en.wikipedia.org/wiki/Database[Databases] - this section mostly focused on how http://en.wikipedia.org/wiki/ACID[ACID] compliant relational databases work and covered things like the http://en.wikipedia.org/wiki/Write-ahead_logging[write ahead log] and index lookups. The recommended reading from this chapter is http://www.amazon.co.uk/Transaction-Processing-Concepts-Techniques-Management/dp/1558601902/ref=sr_1_1?ie=UTF8&qid=1376421544&sr=8-1&keywords=transaction+processing+jim[Transaction Processing: Concepts and Techniques]. Given the fact that many of the popular websites that people use tend to use NoSQL stores these days I thought there might be some mention of that but it was left out. * http://en.wikipedia.org/wiki/Digital_signature[Digital Signatures] - this chapter ties in quite closely with the one on public key cryptography. It focused on signing of software with a digital signature rather than the signing of emails which is what I expected the chapter to be about. The http://en.wikipedia.org/wiki/RSA_(algorithm)[RSA algorithm] is described and the link between the difficultly of http://en.wikipedia.org/wiki/Factorization[factoring] large numbers and the security of the algorithm is explained. I enjoyed the book and I've got some interesting articles/papers to add to my reading list. Even if you already know all the algorithms I think it's interesting to hear them described from a completely different angle to see if you learn something new.

9-algorithms-that-changed-the-future-john-maccormick-book-review

https://markhneedham.com/blog/2013/08/13/9-algorithms-that-changed-the-future-john-maccormick-book-review

2013-08-22 22:11:35

Products & Infinite configurability

One of the common feature requests on the http://www.thoughtworks.com/[ThoughtWorks] projects that I worked on was that the application we were working on should be almost infinitely configurable to cover potential future use cases. My experience of attempting to do this was that you ended up with an extremely complicated code base and those future use cases often didn't come to fruition. It therefore made more sense to *solve the problem at hand* and then make the code more configurable if/when the need arose. Now that I'm working on a product and associated tools I'm trying to understand whether those rules of application development apply. One thing which I think makes sense is the idea of http://en.wikipedia.org/wiki/Convention_over_configuration[convention over configuration], an approach that I became familiar with after working with Ruby/Rails in 2010/2011. ____ The phrase essentially means *a developer only needs to specify unconventional aspects of the application*. ____ Even if we do this I wonder if it goes far enough. The more things we make configurable the more complexity we add and the more opportunity for people to create themselves problems through misconfiguration. Perhaps we should only make a few things configurable and have our application work out appropriate values for everything else. There are a reasonable number of people using a product who don't have much interest in learning how to configure it. They *just want to use it to solve a problem they have* without having to think too much. Although I haven't used it I'm told that http://www.azulsystems.com/products/zing/whatisit[Azul's Zing JVM] takes the minimal configuration approach by only requiring you to specify one parameter - the heap size - and it handles everything else for you. Of course I'm still new to this so perhaps it still does make sense to default most things but allow power users full control in case their use case differs from the average one that the defaults were created for. I'd be interested in hearing the opinions of people more experienced in this arena of which there are undoubtably many.

products-infinite-configurability

https://markhneedham.com/blog/2013/08/22/products-infinite-configurability

2013-08-22 22:56:23

Unix: tar - Extracting, creating and viewing archives

I've been playing around with the Unix http://www.computerhope.com/unix/utar.htm[tar] command a bit this week and realised that I'd memorised some of the flag combinations but didn't actually know what each of them meant. For example, one of the most common things that I want to do is extract a gripped neo4j archive: [source,bash] ---- $ wget http://dist.neo4j.org/neo4j-community-1.9.2-unix.tar.gz $ tar -xvf neo4j-community-1.9.2-unix.tar.gz ---- where: * -x means extract * -v means produce verbose output i.e. print out the names of all the files as you unpack it * -f means unpack the file which follows this flag i.e. neo4j-community-1.9.2-unix.tar.gz in this example I didn't realise that by default tar runs against standard input so we could actually achieve the above in one go with the following combination:</li> ~~~bash $ wget http://dist.neo4j.org/neo4j-community-1.9.2-unix.tar.gz -o - | tar -xv ~~~ The other thing I wanted to do was create a gripped archive from the contents of a folder, something which I do much less frequently and am therefore much more rusty at! The following does the trick: ~~~bash $ tar -cvzpf neo4j-football.tar.gz neo4j-football/ $ ls -alh neo4j-football.tar.gz -rw-r--r-- 1 markhneedham staff 526M 22 Aug 23:38 neo4j-football.tar.gz ~~~ where: * -c means create a new archive * -z means gzip that archive * -p means preserve file permissions Sometimes we'll want to exclude some things from our archive which is where the '--exclude' flag comes in handy. For example I want to exclude the data, git and neo4j folders which sit inside 'neo4j-football' which I can do with the following: ~~~bash $ tar --exclude "data*" --exclude "neo4j-community*" --exclude ".git" -cvzpf neo4j-football.tar.gz neo4j-football/ $ ls -alh neo4j-football.tar.gz -rw-r--r-- 1 markhneedham staff 138M 22 Aug 23:36 neo4j-football.tar.gz ~~~ If we want to quickly check that our file has been created correctly we can run the following: ~~~bash $ tar -tvf neo4j-football.tar.gz ~~~ where: * -t means list the contents of the archive to standard out And that pretty much covers my main use cases for the moment!

unix-tar-extracting-creating-and-viewing-archives

https://markhneedham.com/blog/2013/08/22/unix-tar-extracting-creating-and-viewing-archives

2013-08-22 21:26:10

Model to answer your questions rather than modelling reality

On the recommendation of https://twitter.com/iansrobinson[Ian Robinson] I've been reading the 2nd edition of William's Kent's 'http://www.waterstones.com/waterstonesweb/products/william+kent/data+and+reality/5270709/[Data and Reality]' and the author makes an interesting observation at the end of the first chapter which resonated with me: ____ Once more: we are not modelling reality, but the way information about reality is processed, by people. ____ It reminds me of similar advice in Eric Evans' http://www.amazon.co.uk/Domain-driven-Design-Tackling-Complexity-Software/dp/0321125215[Domain Driven Design] and it's advice which I believe is helpful when designing a model in a graph database. Last year I wrote a post explaining how I'd be using an approach of http://www.markhneedham.com/blog/2012/05/05/neo4j-what-question-do-you-want-to-answer/[defining questions that I wanted to ask] before modelling my data and in http://www.neo4j.org/[neo4j] land we can do this by writing http://docs.neo4j.org/chunked/snapshot/cypher-query-lang.html[cypher] queries up front. We can then play around with increasing the size of our data set in different ways to check that our queries are still performant and tweak our model if necessary. For example one simple optimisation would be to run an offline query to http://www.markhneedham.com/blog/2012/07/21/neo4j-embracing-the-sub-graph/[make implicit relationships explicit]. Although graphs are very http://neo4j.rubyforge.org/guides/why_graph_db.html[whiteboard friendly] and it can be tempting to design our whole model before writing any queries this often causes problems later on. When we eventually get to asking questions of our data we may find that we've modelled some things unnecessarily or have designed the model in a way that leads to inefficient queries. I've found an effective approach is to *keep the feedback loop tight* by minimising the amount of time between drawing parts of our model on a whiteboard and writing queries against it. If you're interested in learning more, Ian has http://flex.winfxpro.info/download/?noderef=workspace://SpacesStore/c1d32b3e-67f1-4f0d-b5b9-b055ebdf9444[a slide deck from a talk he did at JAX 2013] which covers this idea and others when building out graph database applications.

model-to-answer-your-questions-rather-than-modelling-reality

https://markhneedham.com/blog/2013/08/22/model-to-answer-your-questions-rather-than-modelling-reality

2013-01-05 00:25:30

A new year's idea: Share what you learn

_Apologies in advance for how meta this post is_. About 4 1/2 years ago https://twitter.com/thejayfields[Jay Fields] wrote a blog post where http://blog.jayfields.com/2008/08/be-your-start-up.html[he encouraged people to write, present and contribute] and outlined the advantages he'd seen in his career from doing so. In hindsight the bit which stood out the most for me was the following paragraph: ____ Don't know what to write about? The answers are all around you. Anything you do that's interesting, there's 100 people searching Google for how to do it. *Any question a colleague asks you, someone is searching Google for the same answer. Anything that's valuable to you\... yes, someone is googling for it*. ____ Motivated partly by this and partly by the fact that I was working away from home and staying in a hotel overlooking a motorway and had nothing else to do I started documenting what I was learning on here. I've now written over 1,000 posts but have failed to convince any of my friends that they should blog too and make people's Google experience better too! I have however managed to accrue a huge collection of reasons why people don't write about what they're learning and added to a quick twitter survey I did this morning here they are! == I learn more by coding This is the argument that I use against myself the most frequently - surely if my area of interest is programming then I will get better faster by coding more rather than writing about things. I probably convince myself that this is true 4 times out of 5 and then after spending a bit of time reflecting on what I've been doing by writing it up I wish I'd done so earlier! I've also been lucky enough that people much better than me have commented on my posts and showed me ways to improve which would have taken me much longer to discover by myself. I suppose I could have achieved that by going on an IRC channel but this way my whole thought process has been laid out, the code demonstrated and then another way explained. Writing code and putting it on github is awesome but writing a summary article explaining what you were doing and showing people some examples of what they can do with your code is even better. As a final incentive, the title you give the post and the language you use to describe what you're done will probably be more SEO friendly than pure code so others will be more likely to come across it. #win! == I don't have time Obviously I don't know everybody's personal circumstances and I'm sure in some cases it's true that people don't have time but when I explain how long it takes me to write a post people are often surprised. I was fairly sure that on average it takes me less than an hour but I thought I better time myself writing a few of my recent posts so I had some empirical evidence! * http://www.markhneedham.com/blog/2012/12/31/bitwise-operations-in-ruby-and-haskell/[Bit wise operations in Ruby and Haskell] - 1 hour * http://www.markhneedham.com/blog/2012/12/31/gamification-and-software-some-thoughts/[Reality is broken] - 1 hour * http://www.markhneedham.com/blog/2012/12/27/mahout-parallelising-the-creation-of-decisiontrees/[Parallelising Mahout forests] - 1 hour * http://www.markhneedham.com/blog/2013/01/02/haskell-reading-files/[Reading files in Haskell] - 25 minutes * http://www.markhneedham.com/blog/2012/12/24/the-tracer-bullet-approach-an-example/[Tracer Bullet] - 20 minutes * Posts on the http://www.markhneedham.com/blog/2012/12/31/haskell-strictness-and-the-monadic-bind/[union find data structure] http://www.markhneedham.com/blog/2012/12/31/haskell-an-impressively-non-performant-union-find/[in Haskell] - 2 hours I think the belief that it should take much longer than this derives from the thinking that a blog post needs to be a piece of art and that they need to be really extensive and cover every possibility. I try to apply the single responsibility principle when I'm writing and if I start drifting off into a different topic then I copy and paste that text and put it in another post.</li> I have a notepad with me at all times and whenever I see something interesting or something takes longer than it should I sketch out what the problem was and how we solved it and then write it up in the evening It's very easy to procrastinate when writing so I keep http://chrisyeh.blogspot.co.uk/2012/12/my-20-minute-secret-to-being-insanely.html[a pomodoro timer running] and it does the job of keeping me focused as well as providing motivation to try and finish the post within a time box. A bit of gamification always keeps things fun so I originally started out with the intention of writing one post per day which I eventually scaled back to about 16/17 posts a month which I achieved 2/3 of the months of 2012. I find doing that makes me keep my mind open to interesting things to write about and makes me do things that I can then write about. == I'm not doing anything interesting to write about It seems to be a universal truth that http://en.wiktionary.org/wiki/the_grass_is_always_greener_on_the_other_side[what other people are doing sounds more interesting to us than what we're doing]. This means that what you're currently working on is probably interesting to other people even if you don't think it will be. I have friends who have played around/done work with Go, Riak, Cassandra and Clojure to name but a few which sound fascinating to me but still haven't reached the 'interesting' threshold! Briefly brainstorming some other things that I'd find interesting: * Stories from first time/seasoned tech leads describing how they handle situations * How do hypermedia systems work in real life? Some war stories around trying to implement proper REST * How do people go about learning new programming languages? What problems do they run into? There are undoubtably way more interesting topics than what I've come up with - giving the topic your personal angle is often a good way of making the post stand out from other ones on the same topic. == Everybody already knows what I'd write about An interesting thing that I've noticed from 4 years of writing is that what I considered at the time to be my most pointless posts are the ones that are most useful to people. Two examples come to mind. One is a post I wrote in 2010 aggregating a bunch of instructions on http://www.markhneedham.com/blog/2010/07/08/installing-ruby-1-9-2-with-rvm-on-snow-leopard/[compiling Ruby 1.9.2 using RvM on Snow Leopard] - it's been read 25,000 times. The other I wrote at the start of 2012 about the idea of http://www.markhneedham.com/blog/2012/02/20/coding-packaging-by-vertical-slice/[organising code by domain area] rather than by layer which has 30 comments from people sharing their thoughts. Even if you do think everybody already knows what you want to write about it doesn't matter because you're writing first for yourself and then for everybody else. == I'm not good at writing This one is said less frequently but is still a fear for people and in this case I think Jay addresses it best: ____ Writing well is hard, but you're a programmer, so you needn't worry about that. No one expects you to be a good writer, they're happy if you are, but they're forgiving if you're not. Don't use your poor writing skills as an excuse not to write. ____ The only way to get better at writing is to write but 'http://www.amazon.co.uk/Writing-Well-Classic-Guide-Nonfiction/dp/141775057X[On Writing Well]' has some good pointers and describes common mistakes that people make. I still have advice from the book ringing in my head as I write every post. == People will criticise what I write One of the main fears that people seem to have is that what they write will be criticised by others and therefore they need to make sure every possible angle is covered before writing about anything. Out of the 1,000+ posts I've written I can only think of one or two occasions when I've been criticised in a way I didn't think was particularly constructive which at the time wasn't nice but eventually you realise it doesn't actually matter. Most of the time people were very kind if I'd got something wrong and I just corrected it. On the flip side, as I mentioned earlier, people tend to be really helpful and teach me new things by commenting on what I write. == I need to write my own blog I know this one is a bit sarcastic but many people seem to get distracted from sharing what they're learning by spending too much time working out how to do so i.e. writing their own blogging software I use http://wordpress.com/[WordPress] but I think http://pages.github.com/[github pages], http://jekyllbootstrap.com/[Jekyll] or https://www.tumblr.com/[tumblr] are probably better options. I will end the post with the provocative words of Eric Raymond in http://www.catb.org/esr/faqs/hacker-howto.html[How To Become a Hacker]: ____ Creative brains are a valuable, limited resource. They shouldn't be wasted on re-inventing the wheel when there are so many fascinating new problems waiting out there. To behave like a hacker, you have to believe that the thinking time of other hackers is precious -- so much so that *it's almost a moral duty for you to share information, solve problems and then give the solutions away just so other hackers can solve new problems instead of having to perpetually re-address old ones*. ____

a-new-years-idea-share-what-you-learn

https://markhneedham.com/blog/2013/01/05/a-new-years-idea-share-what-you-learn

2013-01-02 00:16:50

Haskell: Reading files

In writing the https://github.com/mneedham/algorithms2/blob/master/clustering.hs[clustering algorithm] which I've mentioned way too many times already I needed to process a text file which contained all the points and my initial approach looked like this: [source,haskell] ---- import System.IO main = do withFile "clustering2.txt" ReadMode (\handle -> do contents <- hGetContents handle putStrLn contents) ---- It felt a bit clunky but I didn't realise there was an easier way until I came across http://stackoverflow.com/questions/7867723/haskell-file-reading[this thread]. We can simplify reading a file to the following by using the +++<cite>+++http://zvon.org/other/haskell/Outputprelude/readFile_f.html[readFile]+++</cite>+++ function: [source,haskell] ---- main = do contents <- readFile "clustering2.txt" putStrLn contents ---- We need to read the file in the IO monad which explains why we have the 'do' notation on the first line. Another thing I http://www.haskell.org/ghc/docs/7.2.2/html/users_guide/interactive-evaluation.html[didn't realise until recently] was that you don't actually need to worry about the 'do' notation if you try to read from the IO monad inside GHCI. In this context we're reading from the IO monad when we bind 'readFile' to the variable 'contents' since 'readFile' returns type 'IO String': [source,text] ---- > :t readFile readFile :: FilePath -> IO String ---- We can therefore play around with the code pretty easily: [source,haskell] ---- > contents <- readFile "clustering2.txt" > let (bits, nodes) = process contents > bits 24 > length nodes 19981 > take 10 nodes [379,1669,5749,6927,7420,9030,9188,9667,11878,12169] ---- I think we're able to do this because by being in GHCI we're already in the context of the IO monad but I'm happy to be corrected if I haven't explained that correctly.

haskell-reading-files

https://markhneedham.com/blog/2013/01/02/haskell-reading-files

2013-01-20 19:14:08

Bellman-Ford algorithm in Python using vectorisation/numpy

I recently http://www.markhneedham.com/blog/2013/01/18/bellman-ford-algorithm-in-python/[wrote about an implementation of the Bellman Ford shortest path algorithm] and concluded by saying that it took 27 seconds to calculate the shortest path in the graph for any node. This seemed a bit slow and while browsing the Coursera forums I came across a suggestion that the algorithm would run much more quickly if we used vectorization with http://www.numpy.org/[numpy] rather than nested for loops. Vectorisation refers to a problem solving approach where we make use of matrices operations which is what numpy allows us to do. To refresh, the core of the original algorithm reads like this: [source,python] ---- for i in range(1, vertices): for v in range(0, vertices): previous_cache = cache least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, previous_cache) cache[v] = min(previous_cache[v], least_adjacent_cost) # detecting negative cycles for v in range(0, vertices): previous_cache = copy.deepcopy(cache) least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, previous_cache) cache[v] = min(previous_cache[v], least_adjacent_cost) if(not cache == previous_cache): raise Exception("negative cycle detected") shortest_path = min(cache) ---- We want to try and simplify the first two lines where we have for loops through +++<cite>+++i+++</cite>+++ and +++<cite>+++v+++</cite>+++. I couldn't see a way to apply matrix operations to the +++<cite>+++i+++</cite>+++ loop since each iteration of +++<cite>+++i+++</cite>+++ makes use of the result of the previous iteration but with the +++<cite>+++v+++</cite>+++ loop the calculation of the shortest path for each vertex is independent of the calculation for other vertices so we can vectorise this bit of code. We want to try and get to the point where we can use numpy's +++<cite>+++http://docs.scipy.org/doc/numpy/reference/generated/numpy.minimum.html[minimum]+++</cite>+++ function where we'd pass in an array representing the previous iteration of +++<cite>+++i+++</cite>+++ and an array that represents the newly calculated cost for each vertex +++<cite>+++v+++</cite>+++. [source,python] ---- # We want to get to this point previous_cache = cache[:] # here we copy the contents of cache into previous_cache cache = minimum(previous_cache, new_shortest_paths) ---- It was initially a bit tricky to see how we could go about this but after sketching it out on paper it became clear that we needed to add the values in +++<cite>+++previous_cache+++</cite>+++ to the weights of the edges between different vertices and then find the minimum combined value for each vertex. It seemed much easier to achieve this if we used an adjacency matrix rather than an adjacency list to represent the graph and if we do that then the following example shows how we'd go about vectorising the algorithm. If our +++<cite>+++previous_cache+++</cite>+++ had the following values: [source,text] ---- 1 2 3 4 5 6 # these are the previous shortest paths for vertex 0,1…,n ---- And our adjacency matrix looked like this: [source,text] ---- inf inf 4 inf inf inf # edges for vertex 0 -2 inf inf inf inf inf # edges for vertex 1 inf -1 inf inf inf inf # and so on... inf inf 2 inf inf 1 inf inf -3 inf inf -4 inf inf inf inf inf inf ---- where the numeric values represent the edge weights between vertices and those with a value of 'inf' don't have a direct edge we'd except the initial combination of these two data structures to look like this: [source,text] ---- inf inf 5 inf inf inf # edges for vertex 0 0 inf inf inf inf inf # edges for vertex 1 inf 2 inf inf inf inf # and so on... inf inf 6 inf inf 5 inf inf 2 inf inf 1 inf inf inf inf inf inf ---- where 1 has been added to every value in the first row, 2 has been added to every value in the second row and so on. We can achieve that with the following code: [source,python] ---- >>> previous = arange(1,7).reshape((1,6)) >>> previous array([[1, 2, 3, 4, 5, 6]]) >>> adjacency_matrix = x = array([[inf,inf,4,inf,inf,inf],[-2,inf,inf,inf,inf,inf],[inf,-1,inf,inf,inf,inf],[inf,inf,2,inf,inf,1],[inf,inf,-3,inf,inf,-4],[inf,inf,inf,inf,inf,inf]]) >>> adjacency_matrix array([[ inf, inf, 4., inf, inf, inf], [ -2., inf, inf, inf, inf, inf], [ inf, -1., inf, inf, inf, inf], [ inf, inf, 2., inf, inf, 1.], [ inf, inf, -3., inf, inf, -4.], [ inf, inf, inf, inf, inf, inf]]) >>> previous.T + adjacency_matrix array([[ inf, inf, 5., inf, inf, inf], [ 0., inf, inf, inf, inf, inf], [ inf, 2., inf, inf, inf, inf], [ inf, inf, 6., inf, inf, 5.], [ inf, inf, 2., inf, inf, 1.], [ inf, inf, inf, inf, inf, inf]]) ---- Here we used the +++<cite>+++http://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html[transpose]+++</cite>+++ function to get our +++<cite>+++previous+++</cite>+++ variable in the right shape so we could apply its first value to every item in the first row of +++<cite>+++adjacency_matrix+++</cite>+++ its second value to every item in the second row and so on. What we actually want is the shortest path for each vertex so we need to take the minimum value from each row for which the +++<cite>+++http://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.min.html[min]+++</cite>+++ function comes in handy. [source,python] ---- >>> result = previous.T + adjacency_matrix >>> result.min(axis=1) array([ 5., 0., 2., 5., 1., inf]) ---- We have to tell it to apply itself to each row by passing 'axis=1' otherwise it will just take the minimum value of the whole matrix. Now to get our newly calculated cache we just need to combine our +++<cite>+++previous+++</cite>+++ value with this new one: [source,python] ---- >>> previous array([[1, 2, 3, 4, 5, 6]]) >>> result.min(axis=1) array([ 5., 0., 2., 5., 1., inf]) >>> minimum(previous, result.min(axis=1)) array([[ 1., 0., 2., 4., 1., 6.]]) ---- Now if we put this into our algorithm it ends up looking like this: [source,python] ---- adjacency_matrix = zeros((vertices, vertices)) adjacency_matrix[:] = float("inf") for line in file.readlines(): tail, head, weight = line.split(" ") adjacency_matrix[int(head)-1][int(tail)-1] = int(weight) def initialise_cache(vertices, s): cache = empty(vertices) cache[:] = float("inf") cache[s] = 0 return cache cache = initialise_cache(vertices, 0) for i in range(1, vertices): previous_cache = cache[:] combined = (previous_cache.T + adjacency_matrix).min(axis=1) cache = minimum(previous_cache, combined) # checking for negative cycles previous_cache = cache[:] combined = (previous_cache.T + adjacency_matrix).min(axis=1) cache = minimum(previous_cache, combined) if(not alltrue(cache == previous_cache)): raise Exception("negative cycle detected") ---- The only numpy function that's new is +++<cite>+++http://www.scipy.org/Numpy_Example_List_With_Doc#head-2cddd526f17674432305ae6deeed1f18673ee560[alltrue]+++</cite>+++ which is used to check whether every value of two arrays is the same. The https://github.com/mneedham/algorithms2/blob/master/shortestpath/shortestpaths-simple.py[code is on github] and the running time is now down from 27 seconds to 5 seconds per shortest path which is pretty cool I think!

bellman-ford-algorithm-in-python-using-vectorisationnumpy

https://markhneedham.com/blog/2013/01/20/bellman-ford-algorithm-in-python-using-vectorisationnumpy

2013-01-20 15:53:02

telnet/netcat: Waiting for a port to be open

On Friday http://junctionbox.ca/[Nathan] and I were setting up a new virtual machine and we needed a firewall rule to be created to allow us to connect to another machine which had some JAR files we wanted to download. We wanted to know when it had been done by one of our operations team and I initially thought we might be able to do that using telnet: [source,text] ---- $ telnet 10.0.0.1 8081 Trying 10.0.0.1... telnet: connect to address 10.0.0.1: Operation timed out telnet: Unable to connect to remote host ---- We wanted to put a http://en.wikipedia.org/wiki/Watch_(Unix)[watch] on the command so that it would be repeated every few seconds and indicate when we'd could connect to the port. However, as as far as I can tell there's no way to reduce the length of the telnet timeout so Nathan suggested using netcat instead. We ended up with the following command... [source,text] ---- $ nc -v -w 1 10.0.0.1 8081 nc: connect to 10.0.0.1 port 8081 (tcp) failed: Connection refused ---- \...which we can then wire up with watch like so: [source,text] ---- $ watch "nc -v -w 1 10.0.0.1 8081" Every 2.0s: nc -v -w 1 10.0.0.1 8081 Sun Jan 20 15:48:05 2013 nc: connect to 10.0.0.1 port 8081 (tcp) timed out: Operation now in progress ---- And then when it works: [source,text] ---- Every 2.0s: nc -v -w 1 10.0.0.1 8081 Sun Jan 20 15:49:53 2013 Connection to 10.0.0.1 8081 port [tcp] succeeded! ----

waiting-for-a-port-to-be-open

https://markhneedham.com/blog/2013/01/20/waiting-for-a-port-to-be-open

2013-01-18 00:40:32

Bellman-Ford algorithm in Python

The latest problem of the https://www.coursera.org/course/algo2[Algorithms 2] class required us to write an algorithm to calculate the http://en.wikipedia.org/wiki/Shortest_path_problem[shortest path between two nodes on a graph] and one algorithm which allows us to do this is http://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm[Bellman-Ford]. Bellman-Ford computes the single source shortest path which means that if we have a 5 vertex graph we'd need to run it 5 times to find the shortest path for each vertex and then find the shortest paths of those shortest paths. One nice thing about Bellman-Ford compared to http://en.wikipedia.org/wiki/Dijkstra's_algorithm[Djikstra] is that it's able to handle negative edge weights. The pseudocode of the algorithm is as follows: * Let +++<cite>+++A+++</cite>+++ = 2-D array of size +++<cite>+++n+++</cite>+++ * +++<cite>+++n+++</cite>+++ where n is the number of vertices * Initialise +++<cite>+++A[0,s] = 0+++</cite>+++; A[0,v] = infinity for all v &ne; +++<cite>+++s+++</cite>+++ where +++<cite>+++s+++</cite>+++ is the node we're finding the shortest path for * for i=1,2,3,...n-1 ** for each v &isin; V *** A[i,v] = min { A[i-1, v], + &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;min (w,v) &isin; E { A[k-1, w] + Cost~wv~ } + &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp} *** where (w,v) are the incoming edges of vertex v * check for negative cycles by running one more time and checking A[n] = A[n-1] * If they are equal then return A[n-1] otherwise report a negative cycle. My first version looked like this: [source,python] ---- import os file = open(os.path.dirname(os.path.realpath(__file__)) + "/g_small.txt") vertices, edges = map(lambda x: int(x), file.readline().replace("\n", "").split(" ")) adjacency_list = [[] for k in xrange(vertices)] for line in file.readlines(): tail, head, weight = line.split(" ") adjacency_list[int(head)-1].append({"from" : int(tail), "weight" : int(weight)}) s=0 cache = [[0 for k in xrange(vertices+1)] for j in xrange(vertices+1)] cache[0][s] = 0 for v in range(0, vertices): if v != s: cache[0][v] = float("inf") for i in range(1, vertices): for v in range(0, vertices): least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, cache[i-1]) cache[i][v] = min(cache[i-1][v], least_adjacent_cost) # detecting negative cycles for v in range(0, vertices): least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, cache[vertices-1]) cache[vertices][v] = min(cache[vertices-1][v], least_adjacent_cost) if(not cache[vertices] == cache[vertices-1]): raise Exception("negative cycle detected") shortest_path = min(cache[vertices-1]) print("Shortest Path: " + str(shortest_path)) ---- where +++<cite>+++calculate_least_adjacent_cost+++</cite>+++ is defined like so: [source,python] ---- def calculate_least_adjacent_cost(adjacency_list, i, v, cache): adjacent_nodes = adjacency_list[v] least_adjacent_cost = float("inf") for node in adjacent_nodes: adjacent_cost = cache[node["from"]-1] + node["weight"] if adjacent_cost < least_adjacent_cost: least_adjacent_cost = adjacent_cost return least_adjacent_cost ---- As you can see we're using an adjacency list as our graph representation, mapping from each node to its corresponding edges. We then initialise the cache as per the algorithm and then have two nested for loops which we use to work out the shortest path from +++<cite>+++s+++</cite>+++ to each vertex. The +++<cite>+++calculate_least_adjacent_cost+++</cite>+++ function is used to work out which of the incoming edges to a vertex has the lowest cost, taking into account previous shortest path calculations that we've done up to the source vertices of those incoming edges. We then have an extra call at the end to check for negative cycles. If there is no change in the values calculated from +++<cite>+++s+++</cite>+++ to each vertex then we know we don't have any negative cycles because otherwise one of them would have come into effect and given us a different result. This algorithm works but it's inefficient in its use of space - our cache has size n*n when we only ever care about 2 of the rows - the previous and current ones - so we can just use a list instead. If we do this the code now looks like this: [source,python] ---- s=0 cache = [[] for j in xrange(vertices+1)] cache[s] = 0 for v in range(0, vertices): if v != s: cache[v] = float("inf") for i in range(1, vertices): for v in range(0, vertices): previous_cache = cache least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, previous_cache) cache[v] = min(previous_cache[v], least_adjacent_cost) # detecting negative cycles for v in range(0, vertices): previous_cache = copy.deepcopy(cache) least_adjacent_cost = calculate_least_adjacent_cost(adjacency_list, i, v, previous_cache) cache[v] = min(previous_cache[v], least_adjacent_cost) if(not cache == previous_cache): raise Exception("negative cycle detected") ---- By doing this we lose the history of the algorithm over the run which means in its current state we wouldn't be able to work our what the shortest path was, we just know its cost. For a 1000 node, 47978 edge graph it takes 27 seconds to go over the whole graph and detect a negative cycle if there is one. The https://github.com/mneedham/algorithms2/blob/master/shortestpath/shortestpaths.py[code for this algorithm] is on github as always.

bellman-ford-algorithm-in-python

https://markhneedham.com/blog/2013/01/18/bellman-ford-algorithm-in-python

2013-01-27 15:14:01

Ruby: invalid multibyte char (US-ASCII)

I've used Ruby on and off for the last few years but somehow had never come across the following error which we got last week while attempting to print out a currency value: +++<cite>+++blah.ruby+++</cite>+++ [source,ruby] ---- amount = "£10.00" puts amount ---- [source,text] ---- $ ruby blah.ruby blah.ruby:1: invalid multibyte char (US-ASCII) blah.ruby:1: invalid multibyte char (US-ASCII) ---- Luckily my pair http://www.linkedin.com/profile/view?id=13286237[Jae] had come across this before and showed me http://blog.grayproductions.net/articles/ruby_19s_three_default_encodings[a blog post which explains what's going on and how to sort it out]. It turns out that since Ruby 1.9 we need to explicitly specify which encoding we want to use for strings otherwise it will default to US-ASCII in my case at least. We can get around this by explicitly telling the interpreter that we want to use UTF-8 encoding by including the following comment at the top of our file: [source,ruby] ---- # encoding: UTF-8 amount = "£10.00" puts amount ---- Then when we interpret the file this time: [source,text] ---- $ ruby blah.ruby £10.00 ---- Since we were only editing one file it made sense to just set the comment manually but if we need to do that in a more widespread way then we'd want to use the https://github.com/m-ryan/magic_encoding[magic_encoding gem]. Yehuda Katz also wrote a post a few years ago http://yehudakatz.com/2010/05/05/ruby-1-9-encodings-a-primer-and-the-solution-for-rails/[explaining all things encoding in more detail].

ruby-invalid-multibyte-char-us-ascii

https://markhneedham.com/blog/2013/01/27/ruby-invalid-multibyte-char-us-ascii

2013-01-27 02:21:39

Python/numpy: Selecting values by multiple indices

As I http://www.markhneedham.com/blog/2013/01/27/pythonnumpy-selecting-specific-column-in-2d-array/[mentioned in my previous post] I've been playing around with http://www.numpy.org/[numpy] and I wanted to get the values of a collection of different indices in a 2D array. If we had a 2D array that looked like this: [source,python] ---- >>> x = arange(20).reshape(4,5) >>> x array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) ---- I knew that it was possible to retrieve the first 3 rows by using the following code: [source,python] ---- >>> x[0:3] array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) ---- What I wanted to do, however, was retrieve the 1st, 3rd and 4th rows which we can do by passing a collection to the array lookup function: [source,python] ---- >>> x[[0,2,3]] array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) ---- My collection of indices was actually in a tuple so I needed to use the +++<cite>+++http://docs.python.org/2/library/functions.html#list[list]+++</cite>+++ function to convert it to the appropriate data structure first: [source,python] ---- >>> x[list((0,2,3))] array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) ---- Pretty neat!

pythonnumpy-selecting-values-by-multiple-indices

https://markhneedham.com/blog/2013/01/27/pythonnumpy-selecting-values-by-multiple-indices

2013-01-27 02:30:05

Python: (Conceptually) removing an item from a tuple

As part of some code I've been playing around I wanted to remove an item from a tuple which wasn't particularly easy because Python's tuple data structure is immutable. I therefore needed to create a new tuple excluding the value which I wanted to remove. I ended up writing the following function to do this but I imagine there might be an easier way because it's quite verbose: [source,python] ---- def tuple_without(original_tuple, element_to_remove): new_tuple = [] for s in list(original_tuple): if not s == element_to_remove: new_tuple.append(s) return tuple(new_tuple) ---- Which can be used like so: [source,python] ---- >>> tuple_without((1,2,3,4), 1) (2, 3, 4) ---- [source,python] ---- >>> tuple_without((1,2,3,4), 0) (1, 2, 3, 4) ---- The easiest approach seemed to be to build up a list containing all the values and then convert it to a tuple by using the +++<cite>+++http://docs.python.org/2/library/functions.html#tuple[tuple]+++</cite>+++ function. It'd be cool if there was a way to transform a tuple like this but I couldn't find such a function in my travels.

python-conceptually-removing-an-item-from-a-tuple

https://markhneedham.com/blog/2013/01/27/python-conceptually-removing-an-item-from-a-tuple

2013-01-27 13:27:32

A/B Testing: Thoughts so far

I've been working at http://www.uswitch.com/[uSwitch] for about two months now and for the majority of that time have been working on an A/B test we were running to try and make it easier for users to go through the energy comparison process. I found the 'http://www.exp-platform.com/Documents/GuideControlledExperiments.pdf[Practical Guide to Controlled Experiments on the Web]' paper useful for explaining how to go about doing an A/B test and there's also http://mcfunley.com/design-for-continuous-experimentation[an interesting presentation by Dan McKinley] about how http://www.etsy.com/[etsy] do A/B testing. I've previously read about A/B tests which changed the page for users on the client side using tools like http://analytics.blogspot.co.uk/2012/06/helping-to-create-better-websites.html[Google Website Optimiser] but since we had made significant changes to the journey we split users on the server side. == Reporting Before we started running our test we needed to work out how we were measuring conversion and how we would get the data to allow us to calculate that. We decided to measure the number of people who started a comparison against the number of those who reached the thank you page and only included those who had an active session from the time we started the experiment. We were already recording the pages users were hitting so it wasn't difficult to write a query to derive the conversion rate. Unfortunately it was taking us a couple of hours to run other queries about the experiment because we had mixed together data about users' sessions and the experiment. The data therefore wasn't optimised for the types of queries we wanted to run. One of our next tasks is to +++<strong>+++split these concerns +++</strong>+++to make our lives a bit easier. == Conversion rate and time I learnt that *people don't necessarily finish a transaction in one sitting* so the conversion rate at the beginning of the experiment isn't representative. We saw it level out after a couple of weeks once we'd gone through a full 'season'. A season is a time period which cover all the days of the week and take into account the average amount of time that people take to go end to end in the process. We've worked out the amount of time that we need to run the test to unequivocally say that the control or experiment has fared better but there is a tendency to kill off the experiment if it's doing significantly worse. I still need to learn when you should stick with it and when it's best to kill it off. == Cognitive biases Although we were http://www.r-tutor.com/elementary-statistics/hypothesis-testing/two-tailed-test-population-proportion[using a hypothesis test] to determine whether the control or experiment was doing better some http://en.wikipedia.org/wiki/Cognitive_bias[cognitive biases] tried to creep in. When we started the experiment most people were fairly convinced that the experiment was going to fare better and so we http://en.wikipedia.org/wiki/Confirmation_bias[really wanted that to happen] and would look for the positives in how it was doing. As with the first example in the etsy talk there was quite a big difference between the two versions and as a result we'd spent a few weeks coding up the experiment and http://en.wikipedia.org/wiki/Sunk_costs#Loss_aversion_and_the_sunk_cost_fallacy[didn't want that work to feel wasted]. == What but not why From the data we could easily see what the users behaviour was but it was much more difficult to understand why that was the case even after drilling down into the data. I hadn't realised that http://en.wikipedia.org/wiki/Usability_testing[user testing] fills this gap quite well because people vocalise what they're thinking when going through the journey and you get an explanation about what other users might be doing as well. One of the suggestions from the etsy talk is to try and make your hypotheses smaller so that you can run *smaller tests with less variables* and therefore have more chance of explaining what's going on. I find this type of stuff fascinating so if anyone has some good papers/articles/blogs where others have written about their experiences I'd love to hear about them. These are some other posts that I've come across: * http://www.cennydd.co.uk/2009/statistical-significance-other-ab-test-pitfalls/[Statistical significance & other A/B test pitfalls] * http://37signals.com/svn/posts/1525-writing-decisions-headline-tests-on-the-highrise-signup-page[Writing Decisions: Headline tests on the Highrise signup page] * http://kylerush.net/blog/optimization-at-the-obama-campaign-ab-testing/[Optimization at the Obama campaign: a/b testing]

ab-testing-thoughts-so-far

https://markhneedham.com/blog/2013/01/27/ab-testing-thoughts-so-far

2013-01-27 02:10:10

Python/numpy: Selecting specific column in 2D array

I've been playing around with http://www.numpy.org/[numpy] this evening in an attempt to improve the performance of a http://en.wikipedia.org/wiki/Travelling_salesman_problem[Travelling Salesman Problem implementation] and I wanted to get every value in a specific column of a 2D array. The array looked something like this: [source,python] ---- >>> x = arange(20).reshape(4,5) >>> x array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) ---- I wanted to get the values for the 2nd column of each row which would return an array containing 1, 6, 11 and 16. For some reason I was expecting it to be quite complicated but in fact we can do this by http://stackoverflow.com/questions/2111163/selecting-specific-column-in-each-row-from-array[using matrix style syntax] like so: [source,python] ---- >>> x[:, 1] array([ 1, 6, 11, 16]) ---- Here we are first saying that we want to return all the rows by specifying ':' and then the '1' indicates that we only want to return the column with index 1. If we wanted to return a specific row as well then we'd specify a value before the comma and it'd be a standard 2D array value lookup: [source,python] ---- >> x[2,1] 11 ---- or [source,python] ---- >> x[2][1] 11 ----

pythonnumpy-selecting-specific-column-in-2d-array

https://markhneedham.com/blog/2013/01/27/pythonnumpy-selecting-specific-column-in-2d-array

2013-01-11 00:40:49

Clojure: Reading and writing a reasonably sized file

In a post a couple of days ago I http://www.markhneedham.com/blog/2013/01/08/kaggle-digit-recognizer-finding-pixels-with-no-variance-using-r/[described some code I'd written in R to find out all the features with zero variance] in the http://www.kaggle.com/c/digit-recognizer[Kaggle Digit Recognizer] data set and yesterday I started working on some code to remove those features. https://twitter.com/jennifersmithco[Jen] and I had previously written some code to parse the training data in Clojure so I thought I'd try and adapt that to write out a new file without the unwanted pixels. In the first version we'd encapsulated the reading of the file and parsing of it into a more useful data structure like so: [source,lisp] ---- (defn get-pixels [pix] (map #( Integer/parseInt %) pix)) (defn create-tuple [[ head & rem]] {:pixels (get-pixels rem) :label head}) (defn tuples [rows] (map create-tuple rows)) (defn parse-row [row] (map #(clojure.string/split % #",") row)) (defn read-raw [path n] (with-open [reader (clojure.java.io/reader path)] (vec (take n (rest (line-seq reader)))))) (def read-train-set-raw (partial read-raw "data/train.csv")) (def parsed-rows (tuples (parse-row (read-train-set-raw 42000)))) ---- So the def +++<cite>+++parsed-rows+++</cite>+++ gives an in memory representation of a row where we've separated the label and pixels into different key entries in a map. We wanted to remove any pixels which had a variance of 0 across the data set which in this case means that they always have a value of 0: [source,lisp] ---- (def dead-to-us-pixels [0 1 2 3 4 5 6 7 8 9 10 11 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 52 53 54 55 56 57 82 83 84 85 111 112 139 140 141 168 196 392 420 421 448 476 532 560 644 645 671 672 673 699 700 701 727 728 729 730 731 754 755 756 757 758 759 760 780 781 782 783]) (defn in? "true if seq contains elm" [seq elm] (some #(= elm %) seq)) (defn dead-to-us? [pixel-with-index] (in? dead-to-us-pixels (first pixel-with-index))) (defn remove-unwanted-pixels [row] (let [new-pixels (->> row :pixels (map-indexed vector) (remove dead-to-us?) (map second))] {:pixels new-pixels :label (:label row)})) (defn -main [] (with-open [wrt (clojure.java.io/writer "/tmp/attempt-1.txt")] (doseq [line parsed-rows] (let [line-without-pixels (to-file-format (remove-unwanted-pixels line))] (.write wrt (str line-without-pixels "\n")))))) ---- We then ran the main method using 'leon run' which wrote out the new file. A print screen of the heap space usage while this function was running looks like this: image::{{<siteurl>}}/uploads/2013/01/encapsulated-read-tiff.jpg[Encapsulated read tiff,406] While I was writing this version of the function I made a mistake somewhere and ended up passing the wrong data structure to one of the functions which resulted in http://www.javamex.com/tutorials/memory/string_memory_usage.shtml[all the intermediate steps that the data structure goes through getting stored in memory] and caused an OutOfMemory exception. A heap dump showed the following: image::{{<siteurl>}}/uploads/2013/01/gone-wrong-tiff.jpg[Gone wrong tiff,600] When I reduced the size of the erroneous collection by using a 'take 10' I got an exception indicating that the function couldn't process the data structure which allowed me to sort it out. I initially thought that the problem was to do with the loading of the file into memory at all but since the above seems to work I don't think it is. When I was working along that theory Jen suggested it might make more sense to do the reading and writing of the files within a 'with-open' which tallies with http://stackoverflow.com/questions/10098402/outofmemory-error-when-processing-a-big-file-in-clojure[a suggestion I came across in a StackOverflow post]. I ended up with the following code: [source,lisp] ---- (defn split-on-comma [line] (string/split line #",")) (defn clean-train-file [] (with-open [rdr (clojure.java.io/reader "data/train.csv") wrt (clojure.java.io/writer "/tmp/attempt-2.csv")] (doseq [line (drop 1 (line-seq rdr))] (let [line-with-removed-pixels ((comp to-file-format remove-unwanted-pixels create-tuple split-on-comma) line)] (.write wrt (str line-with-removed-pixels "\n")))))) ---- Which got called in the main method like this: [source,lisp] ---- (defn -main [] (clean-train-file)) ---- This version had the following heap usage: image::{{<siteurl>}}/uploads/2013/01/all-in-with-open-tiff.jpg[All in with open tiff,403] Its peaks are slightly lower than the first one and it seems like it buffers a bunch of lines, writes them out to the file (and therefore out of memory) and repeats. Any thoughts on this approach are as always very welcome!

clojure-reading-and-writing-a-reasonably-sized-file

https://markhneedham.com/blog/2013/01/11/clojure-reading-and-writing-a-reasonably-sized-file

2013-01-07 00:47:34

Knapsack Problem: Python vs Ruby

The latest algorithm that we had to code in https://www.coursera.org/course/algo2[Algorithms 2] was the http://en.wikipedia.org/wiki/Knapsack_problem[Knapsack problem] which is as follows: ____ The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. ____ We did a slight variation on this in that you could only pick each item once, which is known as the 0-1 knapsack problem. In our case we were given an input file from which you could derive the size of the knapsack, the total number of items and the individual weights & values of each one. The pseudocode of the version of the algorithm which uses a 2D array as part of a dynamic programming solution is as follows: * Let +++<cite>+++A+++</cite>+++ = 2-D array of size +++<cite>+++n+++</cite>+++ (number of items) * +++<cite>+++W+++</cite>+++ (size of the knapsack) * Initialise +++<cite>+++A[0,X] = 0+++</cite>+++ for +++<cite>+++X=0,1,..,W+++</cite>+++ * for i=1,2,3,...n ** for x=0,1,2,\...,w *** A[i,x] = max { A[i-1, x], A[x-1, x-w~i~] + V~i~ } *** where V~i~ is the value of the i^th^ element and W~i~ is the weight of the i^th^ element * return A[n, W] This version runs in O(nW) time and O(nW) space. This is the main body of https://github.com/mneedham/algorithms2/blob/master/knapsack/knapsack.rb[my Ruby solution] for that: [source,ruby] ---- number_of_items,knapsack_size = # calculated from file cache = [].tap { |m| (number_of_items+1).times { m << Array.new(knapsack_size+1) } } cache[0].each_with_index { |value, weight| cache[0][weight] = 0 } (1..number_of_items).each do |i| value, weight = rows[i-1] (0..knapsack_size).each do |x| if weight > x cache[i][x] = cache[i-1][x] else cache[i][x] = [cache[i-1][x], cache[i-1][x-weight] + value].max end end end p cache[number_of_items][knapsack_size] ---- This approach works reasonably well when +++<cite>+++n+++</cite>+++ and +++<cite>+++W+++</cite>+++ are small but in the second part of the problem +++<cite>+++n+++</cite>+++ was 500 and +++<cite>+++W+++</cite>+++ was 2,000,000 which means the 2D array would contain 1 billion entries. If we're storing integers of 4 bytes each in that data structure then the https://www.google.co.uk/search?q=4+bytes+*+1+billion&oq=4+bytes+*+1+billion&aqs=chrome.0.57j0j62l3.3716&sugexp=chrome,mod=0&sourceid=chrome&ie=UTF-8[amount of memory required is 3.72GB] - slightly too much for my machine to handle! Instead a better data structure would be one where we don't have to allocate everything up front but can just fill it in as we go. In this case we can still use an array for the number of items but instead of storing another array in each slot we'll use a dictionary/hash map instead. If we take a bottom up approach to this problem it seems like we end up solving a lot of sub problems which aren't relevant to our final solution so I decided to try a top down recursive approach and this is what I ended up with: [source,ruby] ---- @new_cache = [].tap { |m| (@number_of_items+1).times { m << {} } } def knapsack_cached(rows, knapsack_size, index) return 0 if knapsack_size == 0 || index == 0 value, weight = rows[index] if weight > knapsack_size stored_value = @new_cache[index-1][knapsack_size] return stored_value unless stored_value.nil? return @new_cache[index-1][knapsack_size] = knapsack_cached(rows, knapsack_size, index-1) else stored_value = @new_cache[index-1][knapsack_size] return stored_value unless stored_value.nil? option_1 = knapsack_cached(rows, knapsack_size, index-1) option_2 = value + knapsack_cached(rows, knapsack_size - weight, index-1) return @new_cache[index-1][knapsack_size] = [option_1, option_2].max end end p knapsack_cached(rows, @knapsack_size, @number_of_items-1) ---- The code is pretty similar to the previous version except we're starting from the last item and working our way inwards. We end up storing 2,549,110 items in +++<cite>+++@new_array+++</cite>+++ which we can work out by running this: [source,ruby] ---- p @new_cache.inject(0) { |acc,x| acc + x.length} ---- If we'd used the 2D array that would mean we'd only populated 0.25% of the data structure, truly wasteful! I wanted to do a little bit of profiling on how fast this algorithm ran in Ruby compared to JRuby and I also recently came across http://www.martiansoftware.com/nailgun/[nailgun] - which allows you to http://www.tamingthemindmonkey.com/2012/10/15/jruby-faster-feedback-cycle-using-nailgun[start up a persistent JVM and then run your code via that] instead of starting a new one up each time - so I thought I could play around with that as well!~~~ ~~~ruby # Ruby $ time ruby knapsack/knapsack_rec.rb real 0m18.889s user 0m18.613s sys 0m0.138s # JRuby $ time ruby knapsack/knapsack_rec.rb real 0m6.380s user 0m10.862s sys 0m0.428s # JRuby with nailgun $ ruby --ng-server & # start up the nailgun server $ time ruby --ng knapsack/knapsack_rec.rb real 0m6.734s user 0m0.023s sys 0m0.021s $ time ruby --ng knapsack/knapsack_rec.rb real 0m5.213s user 0m0.022s sys 0m0.021s ~~~ The first run is a bit slow as the JVM gets launched but after that we get a marginal improvement. I thought the JVM startup time would be a bigger proportion of the running time but I guess not! I thought I'd try it out in Python as well because on one of the previous problems https://twitter.com/isaiah_p[Isaiah] had been able to write much faster versions in Python so I wanted to see if that'd be the case here too. This was the https://github.com/mneedham/algorithms2/blob/master/knapsack/knapsack.py[python solution]: ~~~python def knapsack_cached(rows, knapsack_size, index): global cache if(index is 0 or knapsack_size is 0): return 0 else: value, weight = rows[index] if(weight > knapsack_size and knapsack_size not in cache[index-1]): cache[index-1][knapsack_size] = knapsack_cached(rows, knapsack_size, index-1) else: if(knapsack_size not in cache[index-1]): option_1 = knapsack_cached(rows, knapsack_size, index-1) option_2 = value + knapsack_cached(rows, knapsack_size - weight, index-1) cache[index-1][knapsack_size] = max(option_1, option_2) return cache[index-1][knapsack_size] knapsack_size, number_of_items, rows = # worked out from the file result = knapsack_cached(rows, knapsack_size, number_of_items-1) print(result) ~~~ The code is pretty much exactly the same as the Ruby version but interestingly it seems to run more quickly: ~~~python $ time python knapsack/knapsack.py real 0m4.568s user 0m4.480s sys 0m0.078s ~~~ I have no idea why that would be the case but it has been for all the algorithms we've written so far. If anyone has any ideas I'd be intrigued to hear them!

knapsack-problem-python-vs-ruby

https://markhneedham.com/blog/2013/01/07/knapsack-problem-python-vs-ruby

2013-01-09 00:12:25

Knapsack Problem in Haskell

I recently described two versions of the http://www.markhneedham.com/blog/2013/01/07/knapsack-problem-python-vs-ruby/[Knapsack problem written in Ruby and Python] and one common thing is that I used a global cache to store the results of previous calculations. From my experience of coding in Haskell it's not considered very idiomatic to write code like that and although I haven't actually tried it, potentially more tricky to achieve. I thought it'd be interesting to try and write the algorithm in Haskell with that constraint in mind and my first version looked like this: [source,haskell] ---- ref :: a -> IORef a ref x = unsafePerformIO (newIORef x) knapsackCached1 :: [[Int]] -> Int -> Int -> IORef (Map.Map (Int, Int) Int) -> Int knapsackCached1 rows knapsackWeight index cacheContainer = unsafePerformIO $ do cache <- readIORef cacheContainer if index == 0 || knapsackWeight == 0 then do return 0 else let (value:weight:_) = rows !! index best = knapsackCached1 rows knapsackWeight prevIndex cacheContainer in if weight > knapsackWeight && lookupPreviousIn cache == Nothing then do let updatedCache = Map.insert (prevIndex, knapsackWeight) best cache writeIORef cacheContainer updatedCache return $ fromJust $ lookupPreviousIn updatedCache else if lookupPreviousIn cache == Nothing then do let newBest = maximum [best, value + knapsackCached1 rows (knapsackWeight-weight) prevIndex cacheContainer] updatedCache = Map.insert (prevIndex, knapsackWeight) newBest cache writeIORef cacheContainer updatedCache return $ fromJust $ lookupPreviousIn updatedCache else return $ fromJust $ lookupPreviousIn cache where lookupPreviousIn cache = Map.lookup (prevIndex,knapsackWeight) cache prevIndex = index-1 ---- We then call it like this: [source,haskell] ---- let (knapsackWeight, numberOfItems, rows) = process contents cache = ref (Map.empty :: Map.Map (Int, Int) Int) knapsackCached1 rows knapsackWeight (numberOfItems-1) cache ---- As you can see, we're passing around the cache as a parameter where the cache is a Map wrapped inside an http://www.haskell.org/ghc/docs/latest/html/libraries/base/Data-IORef.html[IORef] - a data type which allows us to pass around a mutable variable in the IO monad. We write our new value into the cache on lines 11 and 17 so that our updates to the map will be picked up in the other recursive steps. Apart from that the shape of the code is the same as the Ruby and Python versions except I'm now only using a map with a pair as the key instead of an array + map as in the other versions. The annoying thing about this solution is that we have to pass the cache around as a parameter when it's just a means of optimisation and not part of the actual problem. An alternative solution could be the following where we abstract the writing/reading of the map into a +++<cite>+++memoize+++</cite>+++ function which we wrap our function in: [source,haskell] ---- memoize :: ((Int, Int) -> Int) -> (Int, Int) -> Int memoize fn mapKey = unsafePerformIO $ do let cache = ref (Map.empty :: Map.Map (Int, Int) Int) items <- readIORef cache if Map.lookup mapKey items == Nothing then do let result = fn mapKey writeIORef cache $ Map.insert mapKey result items return result else return (fromJust $ Map.lookup mapKey items) knapsackCached :: [[Int]] -> Int -> Int -> Int knapsackCached rows weight numberOfItems = inner (numberOfItems-1, weight) where inner = memoize (\(i,w) -> if i < 0 || w == 0 then 0 else let best = inner (i-1,w) (vi:wi:_) = rows !! i in if wi > w then best else maximum [best, vi + inner (i-1, w-wi)]) ---- We can call that function like this: [source,haskell] ---- let (knapsackWeight, numberOfItems, rows) = process contents cache = ref (Map.empty :: Map.Map (Int, Int) Int) knapsackCached rows knapsackWeight numberOfItems ---- Here we define an inner function inside +++<cite>+++knapsackCached+++</cite>+++ which is a partial application of the memoize function. We then pass our cache key to that function on the previous line. One thing which I noticed while writing this code is that there is some strangeness around the use of 'in' after let statements. It seems like if you're inside an if/else block you need to use 'in' unless you're in the context of a Monad (do statement) in which case you don't need to. I was staring a screen of compilation errors for about an hour until I realised this! These are the timings for the two versions of the algorithm: [source,text] ---- # First one $ time ./k knapsack2.txt real 0m14.993s user 0m14.646s sys 0m0.320s # Second one $ time ./k knapsack2.txt real 0m12.594s user 0m12.259s sys 0m0.284s ---- I'm still trying to understand exactly how to http://book.realworldhaskell.org/read/profiling-and-optimization.html[profile] http://www.haskell.org/haskellwiki/Performance/GHC[and] http://stackoverflow.com/questions/3276240/tools-for-analyzing-performance-of-a-haskell-program[then] http://www.haskell.org/ghc/docs/7.4.1/html/users_guide/runtime-control.html[optimise] the program so any tips are always welcome.

knapsack-problem-in-haskell

https://markhneedham.com/blog/2013/01/09/knapsack-problem-in-haskell

2013-01-31 22:36:34

Levels of automation

Over the last 18 months or so I've worked on a variety of different projects in different organisations and seen some patterns around the way that automation was done which I thought would be interesting to document. The approaches tend to fall into roughly three categories: == Predominantly Manual This tends to be less frequent these days as most developers have at some stage flicked through http://pragprog.com/the-pragmatic-programmer[The Pragmatic Programmer] and been persuaded that automating away boring and repetitive tasks is probably a good idea. It is still possible to drift into this mode when time pressured and addressing a problem for the first time. The general approach I've seen is to first address the crisis with a manual solution and then automate it so they don't have to handle it manually the next time. There can be a tendency to think that someone is a one off and that the effort it would take to automate it isn't worthwhile. In my experience *if something goes wrong once it's probably going to happen again* at some stage when you least want it to! == Partial Automation This is the stage where you have a few automation scripts for common tasks but there's still some human involvement. It might be that a developer needs to remember which machine to run the script against or which arguments to pass to the script but we're not quite at the 'click a button' stage. Interestingly when we have partial automation it can still feel as if we're solving problems manually because there's still a degree of human interaction involved. An example of this might be that we've fully automated the deployment of a service but manually take a server out of the load balancer, deploy to it, check that it passes a smoke test and then put it back into the load balancer. The main task is automated but we still need to babysit the deployment rather than being able to fire it off and then leave it running in the background while we focus on something else. == Full Automation At the fully automated stage we've abstracted away the complexity around the tasks we're automating and may now be at the stage where it's *possible for a non developer to use the tools we've written*. http://junctionbox.ca/nathan-fisher.html[We] fully automated the earlier service example by making use of http://docs.fabfile.org/en/1.4.3/index.html[Fabric] and http://boto.cloudhackers.com/en/latest/index.html[Boto] to get a collection of the appropriate AWS instances and then automated the removing/adding of them from the load balancer. We also wrote a simple smoke test which used curl to check that the main route returned a 200 response code and aborted the deployment if that wasn't the case. Another example of full automation is creating a dashboard to glue all the different parts together. For example we recently spent a couple of hours creating an interface on top of a bunch of https://github.com/defunkt/resque[Resque] queues. We had previously got in a situation where we knew there were jobs stuck somewhere but didn't know which node they were on because we have queues spread across 12 machines. This makes it easier. I have a tendency to want to automate absolutely everything and it can be tricky to tell when you're overdoing it although it's equally hard to know when you're undergoing it! It's nearly always initially faster manually if you know what you're doing. but in the long run you may just be spending time doing something that a computer can help with. One suggestion was to keep a tally chart of how often you end up doing something manually and then if it reaches a certain threshold put some automation in place.

levels-of-automation

https://markhneedham.com/blog/2013/01/31/levels-of-automation

2013-01-31 23:24:55

Kaggle Digit Recognizer: A feature extraction #fail

I've written http://www.markhneedham.com/blog/tag/kaggle/[a few blog posts] about our attempts at the http://www.kaggle.com/c/digit-recognizer[Kaggle Digit Recogniser] problem and one thing we haven't yet tried is feature extraction. Feature extraction in this context means that we'd generate some other features to train a classifier with rather than relying on just the pixel values we were provided. Every week https://twitter.com/jennifersmithco[Jen] would try and persuade me that we should try it out but it wasn't until I was flicking through http://columbiadatascience.com/2012/10/15/10-important-data-science-ideas/[the notes from the Columbia Data Science class] that it struck home: ____ The Space between the Data Set and the Algorithm *Many people go straight from a data set to applying an algorithm*. But there's a huge space in between of important stuff. It's easy to run a piece of code that predicts or classifies. That's not the hard part. The hard part is doing it well. One needs to conduct exploratory data analysis as I've emphasized; and conduct feature selection as Will Cukierski emphasized. ____ I've highlighted the part of the post which describes exactly what we've been doing! There were some http://www.kaggle.com/c/digit-recognizer/forums/t/2308/feature-extraction-technique[examples of feature extraction] on the Kaggle forums so I thought I'd try and create some other features using http://www.markhneedham.com/blog/category/r/[R]. I created features for the number of non zero pixels, the number of 255 pixels, the average number of pixels and the average of the middle pixels of a number. The code reads like this: [source,r] ---- initial <- read.csv("train.csv", header = TRUE) initial$nonZeros <- apply(initial, 1, function(entries) length(Filter(function (x) x != 0, entries))) initial$fullHouses <- apply(initial, 1, function(entries) length(Filter(function (x) x == 255, entries))) initial$meanPixels <- apply(initial, 1, mean) initial$middlePixels <- apply(initial[,200:500], 1, mean) ---- I then wrote those features out into a CSV file like so: [source,r] ---- newFeatures <- subset(initial, select=c(label, nonZeros, meanPixels, fullHouses, middlePixels)) write.table(file="feature-extraction.txt", newFeatures, row.names=FALSE, sep=",") ---- I then created a http://www.markhneedham.com/blog/2012/12/27/mahout-parallelising-the-creation-of-decisiontrees/[100 tree random forest using Mahout] to see whether or not we could get any sort of accuracy using these features. Unfortunately the accuracy on the cross validation set (10% of the training data) was only 24% which is pretty useless so it's back to the drawing board! Our next task is to try and work out whether we can derive some features which have a stronger correlation with the label values or combining the new features with the existing pixel values to see if that has any impact. As you can probably tell I don't really understand how you should go about extracting features so if anybody has ideas or papers/articles I can read to learn more please let me know in the comments!

kaggle-digit-recognizer-a-feature-extraction-fail

https://markhneedham.com/blog/2013/01/31/kaggle-digit-recognizer-a-feature-extraction-fail

2013-01-08 00:48:07

Kaggle Digit Recognizer: Finding pixels with no variance using R

I've http://www.markhneedham.com/blog/2012/10/27/kaggle-digit-recognizer-k-means-optimisation-attempt/[written] http://www.markhneedham.com/blog/2012/11/29/kaggle-digit-recognizer-weka-adaboost-attempt/[previously] http://www.markhneedham.com/blog/2012/10/23/kaggle-digit-recognizer-a-k-means-attempt/[about] http://www.markhneedham.com/blog/2012/10/27/kaggle-digit-recognizer-mahout-random-forest-attempt/[our] http://www.markhneedham.com/blog/2012/12/27/mahout-parallelising-the-creation-of-decisiontrees/[attempts] at the http://www.kaggle.com/c/digit-recognizer[Kaggle Digit Recogniser] problem and our approach so far has been to use the data provided and plug it into different algorithms and see what we end up with. From http://www.kaggle.com/c/digit-recognizer/forums/t/2308/feature-extraction-technique?page=2[browsing through the forums] we saw others mentioning feature extraction - an approach where we transform the data into another format , the thinking being that we can train a better classifier with better data. There was quite a nice quote from a post written by Rachel Schutt about the Columbia Data Science course which http://columbiadatascience.com/2012/10/15/10-important-data-science-ideas/[summed up the mistake we'd made]: ____ The Space between the Data Set and the Algorithm Many people go straight from a data set to applying an algorithm. But there's a huge space in between of important stuff. It's easy to run a piece of code that predicts or classifies. That's not the hard part. The hard part is doing it well. ____ One thing we'd noticed while visually scanning the data set was that a lot of the features seemed to consistently have a value of 0. We thought we'd try and find out which pixels those were by finding the features which had zero variance in their values. I started out by loading a subset of the data set and then taking a sample of that to play around with: [source,r] ---- initial <- read.csv("train.csv", nrows=10000, header = TRUE) # take a sample of 1000 rows of the input sampleSet <- initial[sample(1:nrow(initial), 1000), ] ---- Just for fun I thought it'd be interesting to see how well the labels were distributed in my sample which we can do with the following code: [source,r] ---- # get all the labels sampleSet.labels <- as.factor(sampleSet$label) > table(sampleSet.labels) sampleSet.labels 0 1 2 3 4 5 6 7 8 9 102 116 100 97 95 91 79 122 102 96 ---- There are a few more 1's and 7s than the other labels but they're roughly in the same ballpark so it's ok. I wanted to http://stackoverflow.com/questions/6286313/remove-an-entire-column-from-a-data-frame-in-r[exclude the 'label' field] from the data set because the variance of labels isn't interesting to us on this occasion. We can do that with the following code: [source,r] ---- # get data set excluding label excludingLabel <- subset( sampleSet, select = -label) ---- To find all the features with no variance we then do this: [source,r] ---- # show all the features which don't have any variance - all have the same value variances <- apply(excludingLabel, 2, var) # get the names of the labels which have no variance > pointlessFeatures <- names(excludingLabel[variances == 0][1,]) [1] "pixel0" "pixel1" "pixel2" "pixel3" "pixel4" "pixel5" "pixel6" "pixel7" [9] "pixel8" "pixel9" "pixel10" "pixel11" "pixel12" "pixel13" "pixel14" "pixel15" [17] "pixel16" "pixel17" "pixel18" "pixel19" "pixel20" "pixel21" "pixel22" "pixel23" [25] "pixel24" "pixel25" "pixel26" "pixel27" "pixel28" "pixel29" "pixel30" "pixel31" [33] "pixel32" "pixel33" "pixel51" "pixel52" "pixel53" "pixel54" "pixel55" "pixel56" [41] "pixel57" "pixel58" "pixel59" "pixel60" "pixel82" "pixel83" "pixel84" "pixel85" [49] "pixel86" "pixel88" "pixel110" "pixel111" "pixel112" "pixel113" "pixel114" "pixel139" [57] "pixel140" "pixel141" "pixel142" "pixel168" "pixel169" "pixel196" "pixel252" "pixel280" [65] "pixel308" "pixel335" "pixel336" "pixel364" "pixel365" "pixel392" "pixel393" "pixel420" [73] "pixel421" "pixel448" "pixel476" "pixel504" "pixel532" "pixel559" "pixel560" "pixel587" [81] "pixel615" "pixel643" "pixel644" "pixel645" "pixel671" "pixel672" "pixel673" "pixel699" [89] "pixel700" "pixel701" "pixel727" "pixel728" "pixel729" "pixel730" "pixel731" "pixel752" [97] "pixel753" "pixel754" "pixel755" "pixel756" "pixel757" "pixel758" "pixel759" "pixel760" [105] "pixel779" "pixel780" "pixel781" "pixel782" "pixel783" ---- We can count how many labels there are by using the +++<cite>+++length+++</cite>+++ function: [source,r] ---- # count how many labels have no variance > length(names(excludingLabel[apply(excludingLabel, 2, var) == 0][1,])) [1] 109 ---- I then wrote those out to a file so that we could use them as the input to the code which builds up our classifier. [source,r] ---- write(file="pointless-features.txt", pointlessFeatures) ---- Of course we should run the variance test against the full data set rather than just a sample and on the whole data set there are only 76 features with zero variance: [source,r] ---- > sampleSet <- read.csv("train.csv", header = TRUE) > sampleSet.labels <- as.factor(sampleSet$label) > table(sampleSet.labels) sampleSet.labels 0 1 2 3 4 5 6 7 8 9 4132 4684 4177 4351 4072 3795 4137 4401 4063 4188 > excludingLabel <- subset( sampleSet, select = -label) > variances <- apply(excludingLabel, 2, var) > pointlessFeatures <- names(excludingLabel[variances == 0][1,]) > length(names(excludingLabel[apply(excludingLabel, 2, var) == 0][1,])) [1] 76 ---- We've built decision trees using this reduced data set but haven't yet submitted the forest to Kaggle to see if it's any more accurate! I picked up the little R I know from the https://class.coursera.org/compdata-002/class/index[Computing for Data Analysis] course which started last week and from the book 'http://www.amazon.co.uk/R-in-a-Nutshell-ebook/dp/B009HE12MK/ref=sr_1_1?ie=UTF8&qid=1357606031&sr=8-1[R in a Nutshell]' which my colleague https://twitter.com/quantisan[Paul Lam] recommended.

kaggle-digit-recognizer-finding-pixels-with-no-variance-using-r

https://markhneedham.com/blog/2013/01/08/kaggle-digit-recognizer-finding-pixels-with-no-variance-using-r

2013-01-23 23:09:28

R: Ordering rows in a data frame by multiple columns

In one of the assignments of https://www.coursera.org/course/compdata[Computing for Data Analysis] we needed to sort a data frame based on the values in two of the columns and then return the top value. The initial data frame looked a bit like this: [source,r] ---- > names <- c("paul", "mark", "dave", "will", "john") > values <- c(1,4,1,2,1) > smallData <- data.frame(name = names, value = values) > smallData name value 1 paul 1 2 mark 4 3 dave 1 4 will 2 5 john 1 ---- I want to be able to http://stackoverflow.com/questions/1296646/how-to-sort-a-dataframe-by-columns-in-r[sort the data frame by value and name both in ascending order] so the final result should look like this: [source,text] ---- name value 3 dave 1 5 john 1 1 paul 1 4 will 2 2 mark 4 ---- To do that we can use the +++<cite>+++http://stat.ethz.ch/R-manual/R-patched/library/base/html/order.html[order]+++</cite>+++ function which will tell us the indices of the vector in sorted order. e.g. in our case [source,r] ---- > order(c(1,4,1,2,1)) [1] 1 3 5 4 2 ---- If we pass a collection of indices to the extract operation it'll reorder the rows. e.g. [source,r] ---- > smallData[c(5,4,3,2,1),] name value 5 john 1 4 will 2 3 dave 1 2 mark 4 1 paul 1 ---- In our case we wire everything together like this to sort by the second column (value): [source,r] ---- > smallData[order(smallData[,2]),] name value 1 paul 1 3 dave 1 5 john 1 4 will 2 2 mark 4 ---- It's a reasonably small tweak to get it to sort first by the second column and then by the first (name) which is what we want: [source,r] ---- > smallData[order(smallData[,2], smallData[,1]),] name value 3 dave 1 5 john 1 1 paul 1 4 will 2 2 mark 4 ---- If we wanted to use the column names instead of indices we'd do the following: [source,r] ---- > smallData[order(smallData$value, smallData$name),] name value 3 dave 1 5 john 1 1 paul 1 4 will 2 2 mark 4 ---- We could also rewrite it using the +++<cite>+++with+++</cite>+++ function if we want to reduce the code further: [source,r] ---- > smallData[with(smallData, order(value, name)),] name value 3 dave 1 5 john 1 1 paul 1 4 will 2 2 mark 4 ---- As I understand it, when we use +++<cite>+++with+++</cite>+++ we put +++<cite>+++smallData+++</cite>+++ into the environment and evaluate the second argument to +++<cite>+++with+++</cite>+++ with respect to that so in this case it allows us to refer to the column names of +++<cite>+++smallData+++</cite>+++.

r-ordering-rows-in-a-data-frame-by-multiple-columns

https://markhneedham.com/blog/2013/01/23/r-ordering-rows-in-a-data-frame-by-multiple-columns

2013-01-23 22:34:01

R: Filter a data frame based on values in two columns

In the most recent assignment of the https://www.coursera.org/course/compdata[Computing for Data Analysis] course we had to filter a data frame which contained N/A values in two columns to only return rows which had no N/A's. I started with a data frame that looked like this: [source,r] ---- > data <- read.csv("specdata/002.csv") > # we'll just use a few rows to make it easier to see what's going on > data[2494:2500,] Date sulfate nitrate ID 2494 2007-10-30 3.25 0.902 2 2495 2007-10-31 NA NA 2 2496 2007-11-01 NA NA 2 2497 2007-11-02 6.56 1.270 2 2498 2007-11-03 NA NA 2 2499 2007-11-04 NA NA 2 2500 2007-11-05 6.10 0.772 2 ---- We want to only return the rows which have a value in both the 'sulfate' and the 'nitrate' columns. I initially tried to use the +++<cite>+++http://www.r-bloggers.com/filtering-a-list-with-the-filter-higher-order-function/[Filter]+++</cite>+++ function but wasn't very successful: [source,r] ---- > smallData <- data[2494:2500,] > Filter(function(x) !is.na(x$sulfate), smallData) Error in x$sulfate : $ operator is invalid for atomic vectors ---- I'm not sure that +++<cite>+++Filter+++</cite>+++ is designed to filter data frames - it seems more appropriate for lists or vectors - so I ended up filtering the data frame using what I think is called an extract operation: [source,r] ---- > smallData[!is.na(smallData$sulfate) & !is.na(smallData$nitrate),] Date sulfate nitrate ID 2494 2007-10-30 3.25 0.902 2 2497 2007-11-02 6.56 1.270 2 2500 2007-11-05 6.10 0.772 2 ---- The code inside the square brackets returns a collection indicating whether or not we should return each row: [source,r] ---- > !is.na(smallData$sulfate) & !is.na(smallData$nitrate) [1] TRUE FALSE FALSE TRUE FALSE FALSE TRUE ---- which is equivalent to doing this: [source,r] ---- > smallData[c(TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE),] Date sulfate nitrate ID 2494 2007-10-30 3.25 0.902 2 2497 2007-11-02 6.56 1.270 2 2500 2007-11-05 6.10 0.772 2 ---- We put a comma after the list of true/false values to indicate that we want to return all the columns otherwise we'd get this error: [source,r] ---- > smallData[c(TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE)] Error in `[.data.frame`(smallData, c(TRUE, FALSE, FALSE, TRUE, FALSE, : undefined columns selected ---- We could filter the columns as well if we wanted to: [source,r] ---- > smallData[c(TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE), c(1,2)] Date sulfate 2494 2007-10-30 3.25 2497 2007-11-02 6.56 2500 2007-11-05 6.10 ---- As is no doubt obvious, I don't know much R so if there's a better way to do anything please let me know. The https://github.com/mneedham/dataanalysis/blob/master/week2/complete.R[full code is on github] if you're interested in seeing it in context.

r-filter-a-data-frame-based-on-values-in-two-columns

https://markhneedham.com/blog/2013/01/23/r-filter-a-data-frame-based-on-values-in-two-columns

2013-01-15 00:37:01

Fabric/Boto: boto.exception.NoAuthHandlerFound: No handler was ready to authenticate. 1 handlers were checked. ['QuerySignatureV2AuthHandler'] Check your credentials

In our Fabric code we make use of https://github.com/boto/boto[Boto] to connect to the EC2 API and pull back various bits of information and the first time anyone tries to use it they end up with the following stack trace: [source,text] ---- File "/Library/Python/2.7/site-packages/fabric/main.py", line 717, in main *args, **kwargs File "/Library/Python/2.7/site-packages/fabric/tasks.py", line 332, in execute results['<local-only>'] = task.run(*args, **new_kwargs) File "/Library/Python/2.7/site-packages/fabric/tasks.py", line 112, in run return self.wrapped(*args, **kwargs) File "/Users/mark/projects/forward-puppet/ec2.py", line 131, in running instances = instances_by_zones(running_instances(region, role_name)) File "/Users/mark/projects/forward-puppet/ec2.py", line 19, in running_instances ec2conn = ec2.connect_to_region(region) File "/Library/Python/2.7/site-packages/boto/ec2/__init__.py", line 57, in connect_to_region for region in regions(**kw_params): File "/Library/Python/2.7/site-packages/boto/ec2/__init__.py", line 39, in regions c = EC2Connection(**kw_params) File "/Library/Python/2.7/site-packages/boto/ec2/connection.py", line 94, in __init__ validate_certs=validate_certs) File "/Library/Python/2.7/site-packages/boto/connection.py", line 936, in __init__ validate_certs=validate_certs) File "/Library/Python/2.7/site-packages/boto/connection.py", line 548, in __init__ host, config, self.provider, self._required_auth_capability()) File "/Library/Python/2.7/site-packages/boto/auth.py", line 633, in get_auth_handler 'Check your credentials' % (len(names), str(names))) boto.exception.NoAuthHandlerFound: No handler was ready to authenticate. 1 handlers were checked. ['QuerySignatureV2AuthHandler'] Check your credentials ---- We http://stackoverflow.com/questions/5396932/why-are-no-amazon-s3-authentication-handlers-ready[haven't told Boto about our AWS credentials] and I've come across two ways of providing them: == As environment variables [source,text] ---- export AWS_ACCESS_KEY_ID="aws_access_key_id" export AWS_SECRET_ACCESS_KEY="aws_secret_access_key" ---- == In the file +++<cite>+++~/.boto+++</cite>+++ [source,text] ---- [Credentials] aws_access_key_id = aws_access_key_id aws_secret_access_key = aws_secret_access_key ---- And that should do the trick!

fabricboto-boto-exception-noauthhandlerfound-no-handler-was-ready-to-authenticate-1-handlers-were-checked-querysignaturev2authhandler-check-your-credentials

https://markhneedham.com/blog/2013/01/15/fabricboto-boto-exception-noauthhandlerfound-no-handler-was-ready-to-authenticate-1-handlers-were-checked-querysignaturev2authhandler-check-your-credentials

2013-01-15 00:20:49

Fabric: Tailing log files on multiple machines

We wanted to tail one of the log files simultaneously on 12 servers this afternoon to try and see if a particular event was being logged and rather than opening 12 SSH sessions decided to get http://docs.fabfile.org/en/1.5/[Fabric] to help us out. My initial attempt to do this was the following: [source,text] ---- fab -H host1,host2,host3 -- tail -f /var/www/awesome/current/log/production.log ---- It works but the problem is that by default Fabric runs the specified command http://docs.fabfile.org/en/1.4.4/usage/execution.html#execution-strategy[one machine after the other] so we've actually managed to block Fabric with the tail command on 'host1'. The output of host1's log file will be printed to the terminal but nothing from the other two hosts. http://junctionbox.ca/[Nathan] showed me how to get around this problem by making use of Fabric's parallel execution which we can enable with the '-P' option: [source,text] ---- fab -P --linewise -H host1,host2,host3 -- tail -f /var/www/awesome/current/log/production.log ---- We also used the 'likewise' flag to ensure that data between the different tail processes didn't get mixed up although this wasn't necessary because Fabric http://docs.fabfile.org/en/1.4.4/usage/parallel.html[defaults to likewise if you're using parallel execution] mode anyway. On a side-note, http://oobaloo.co.uk/kafka-for-uswitchs-event-pipeline[Paul Ingles wrote up the approach taken to make data from log files more accessible] using a Kafka driven event pipeline but in this case we haven't got round to wiring this data up yet so Fabric it is for now.

fabric-tailing-log-files-on-multiple-machines

https://markhneedham.com/blog/2013/01/15/fabric-tailing-log-files-on-multiple-machines

2013-06-04 23:16:29

Ego Depletion

On the recommendation of https://twitter.com/michael_jones[Mike Jones] I've been reading through Daniel Kahneman's http://www.amazon.co.uk/Thinking-Fast-Slow-Daniel-Kahneman/dp/0141033576/ref=sr_1_1?ie=UTF8&qid=1370274373&sr=8-1&keywords=thinking+fast+and+slow[Thinking Fast and Slow] in which the first part of the book covers our two styles of thinking: * *System 1* - operates automatically and quickly, with little or no effort and no sense of voluntary control. * *System 2* - allocates attention to the effortful mental activities that demand it, including complex computations. The operations of System 2 are often associated with the subjective experience of agency, choice, and concentration. He then uses a series of stories to explain this in more detail but I found an experiment run by Roy Baumeister the most interesting: ____ A series of surprising experiments [\...] has shown conclusively that all variants of voluntary effort - cognitive, emotional, or physical - draw at least partly on a shared pool of mental energy. Their experiments involve successive rather than simultaneous tasks. Baumeister's group has repeatedly found that an effort of will or self control is tiring; if you have had to force yourself to do something, you are less willing or less able to exert self-control when the next challenge comes around. The phenomenon has been named *ego depletion*. ____ This particularly resonates with me as I've frequently seen people (including myself) let a series of events involving another person to go by before finally snapping over something seemingly innocuous. Quite frequently the other person had no idea that the way they were behaving was irritating so the reaction comes as a surprise to them! We can get around this problem to some extent by http://www.markhneedham.com/blog/2013/05/23/feedback-reacting-immediately/[providing timely feedback] but in order for that to happen I think we need to admit to ourselves when we are frustrated rather than pretending that it doesn't bother us. It will probably feel silly to address these innocuous events so early on when we don't think they're bothering us that much but I think it's better than the explosive alternative!

ego-depletion

https://markhneedham.com/blog/2013/06/04/ego-depletion

2013-06-20 06:31:11

neo4j/cypher: CREATE with optional properties

I've written before about using the http://docs.neo4j.org/chunked/milestone/query-create.html[cypher CREATE statement] to http://www.markhneedham.com/blog/2013/05/25/neo4jcypher-properties-or-relationships-its-easy-to-switch/[add inferred information to a neo4j graph] and sometimes we want to do that but have to deal with optional properties while creating our new relationships. For example let's say we have the following people in our graph with the 'started' and 'left' properties representing their tenure at a company: [source,cypher] ---- CREATE (person1 { personId: 1, started: 1361708546 }) CREATE (person2 { personId: 2, started: 1361708546, left: 1371708646 }) CREATE (company { companyId: 1 }) ---- We want to create a 'TENURE' link from them to the company including the 'started' and 'left' properties when applicable and might start with the following query: [source,cypher] ---- START person = node:node_auto_index('personId:1 personId:2'), company = node:node_auto_index('companyId:1') CREATE person-[:TENURE_AT { started: person.started, left: person.left }]-company RETURN person, company ---- which throws an exception because not all people have a 'left' property: [source,text] ---- Error: org.neo4j.cypher.EntityNotFoundException: The property 'left' does not exist on Node[1] ---- We tweak our query a bit to make the property optional: [source,cypher] ---- START person = node:node_auto_index('personId:1 personId:2'), company = node:node_auto_index('companyId:1') CREATE person-[:TENURE_AT { started: person.started, left: person.left? }]-company RETURN person, company ---- which still doesn't work: [source,text] ---- Error: java.lang.IllegalArgumentException: Null parameter, key=left, value=null ---- After looking at this for a while https://twitter.com/apcj[Alistair] pointed out that we should just split the updating of the optional property from the creation of the relationship so we end up with the following: [source,cypher] ---- START person = node:node_auto_index('personId:1 personId:2'), company = node:node_auto_index('companyId:1') CREATE person-[tenure:TENURE_AT { started: person.started }]-company WITH person, tenure, company WHERE HAS(person.left) SET tenure.left = person.left RETURN person, company ---- The http://console.neo4j.org/?id=gdbpuv[code is on the console] if you want to see how it works.

neo4jcypher-create-with-optional-properties

https://markhneedham.com/blog/2013/06/20/neo4jcypher-create-with-optional-properties

2013-06-20 07:21:46

neo4j: A simple example using the JDBC driver

https://twitter.com/mesirii[Michael] recently pointed me to the https://github.com/rickardoberg/neo4j-jdbc[neo4j JDBC driver] which he and https://twitter.com/rickardoberg[Rickard] have written so I thought I'd try and port http://www.markhneedham.com/blog/2013/06/20/neo4jcypher-create-with-optional-properties/[the code from my previous post] to use that instead of the console. To start with I added the following dependencies to my POM file: [source,xml] ---- <dependencies> ... <dependency> <groupId>org.neo4j</groupId> <artifactId>neo4j-jdbc</artifactId> <version>1.9</version> </dependency> </dependencies> <repositories> <repository> <id>neo4j-maven</id> <name>neo4j maven</name> <url>http://m2.neo4j.org</url> </repository> </repositories> ---- I then tried to create a connection to a local neo4j server instance that I had running on port 7474: [source,java] ---- Neo4jConnection connect = new Driver(). connect("jdbc:neo4j://localhost:7474", new Properties()); ---- which leads to the following exception: [source,text] ---- Exception in thread "main" java.lang.NoClassDefFoundError: org/neo4j/cypherdsl/grammar/Execute at org.neo4j.jdbc.Driver.<init>(Driver.java:52) at org.neo4j.jdbc.Driver.<clinit>(Driver.java:43) at com.centrica.bigquery.JDBCTest.main(JDBCTest.java:17) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) Caused by: java.lang.ClassNotFoundException: org.neo4j.cypherdsl.grammar.Execute at java.net.URLClassLoader$1.run(URLClassLoader.java:366) at java.net.URLClassLoader$1.run(URLClassLoader.java:355) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:354) at java.lang.ClassLoader.loadClass(ClassLoader.java:423) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308) at java.lang.ClassLoader.loadClass(ClassLoader.java:356) ... 8 more ---- It turns out we also need to add the following dependency: [source,xml] ---- <dependency> <groupId>org.neo4j</groupId> <artifactId>neo4j-cypher-dsl</artifactId> <version>1.9</version> </dependency> ---- We can now run the following code to create some people and then query for one of them: [source,java] ---- Neo4jConnection connect = new Driver(). connect("jdbc:neo4j://localhost:7474", new Properties()); List<String> dataLoad = new ArrayList<String>(); dataLoad.add("CREATE (person1 { personId: 1, started: 1361708546 })"); dataLoad.add("CREATE (person2 { personId: 2, started: 1361708546, left: 1371708646 })"); dataLoad.add("CREATE (company { companyId: 1 })"); connect.createStatement().executeQuery(StringUtils.join(dataLoad, "\n")); ResultSet resultSet = connect.createStatement(). executeQuery("START person1 = node:node_auto_index('personId:1') RETURN person1"); if(resultSet.next()) { Map<String, Object> e = (Map<String, Object>) resultSet.getObject("person1"); System.out.println("personId: " + e.get("personId") + ", started: " + e.get("started")); } ---- which gives the following output: [source,text] ---- Connecting to URL http://localhost:7474 Starting the Apache HTTP client Executing query: START person1 = node:node_auto_index('personId:1') RETURN person1 with params{} Starting the Apache HTTP client personId: 1, started: 1361708546 ---- I haven't done much more with it but JDBC seems like quite a neat integration point because so many other understand that API.

neo4j-a-simple-example-using-the-jdbc-driver

https://markhneedham.com/blog/2013/06/20/neo4j-a-simple-example-using-the-jdbc-driver

2013-06-27 10:32:18

neo4j/cypher: Aggregating relationships within a path

I recently came across an interesting use case of paths in a graph where we wanted to calculate the frequency of communication between two people by showing how frequently each emailed the other. The model looked like this: image::{{<siteurl>}}/uploads/2013/06/emails.png[Emails,458] which we can create with the following cypher statements: [source,cypher] ---- CREATE (email1 { name: 'Email 1', title: 'Some stuff' }) CREATE (email2 { name: 'Email 2', title: "Absolutely irrelevant" }) CREATE (email3 { name: 'Email 3', title: "Something else" }) CREATE (person1 { name: 'Mark' }) CREATE (person2 { name: 'Jim' }) CREATE (person3 { name: 'Alistair' }) CREATE (person1)-[:SENT]->(email1) CREATE (person2)-[:RECEIVED]->(email1) CREATE (person3)-[:RECEIVED]->(email1) CREATE (person1)-[:SENT]->(email2) CREATE (person2)-[:RECEIVED]->(email2) CREATE (person2)-[:SENT]->(email3) CREATE (person1)-[:RECEIVED]->(email3) ---- We want to return a list containing pairs of people and how many times they emailed each other, so in this case we want to return a table showing the following: [source,text] ---- +-------------------------------------------+ | Person 1 | Person 2 | P1 -> P2 | P2 -> P1 | |-------------------------------------------| | Alistair | Mark | 0 | 1 | | Jim | Mark | 1 | 2 | +-------------------------------------------+ ---- I started out with the following query which finds all the emails and then traverses out to find the sender and receiver and aggregates them together: [source,cypher] ---- START email = node:node_auto_index('name:"Email 1" name:"Email 2" name: "Email 3"') MATCH sender-[:SENT]->email<-[:RECEIVED]-receiver RETURN sender.name, receiver.name, COUNT(email) AS count ---- which returns the following: [source,text] ---- ==> +-------------------------------------+ ==> | sender.name | receiver.name | count | ==> +-------------------------------------+ ==> | "Mark" | "Jim" | 2 | ==> | "Jim" | "Mark" | 1 | ==> | "Mark" | "Alistair" | 1 | ==> +-------------------------------------+ ---- It gives us all the pairs that have sent emails to each other but doesn't group them together which is a bit annoying. Having realised that it was quite difficult to get that grouping of people if I started from the emails I changed the query to start from people instead and then traverse in on the emails they'd written to each other: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"') MATCH personA-[s:SENT]->email<-[r:RECEIVED]-personB WHERE personA <> personB WITH personA, personB, LENGTH(COLLECT(s)) AS AToB MATCH personB-[s?:SENT]->email<-[r:RECEIVED]-personA RETURN personA.name, personB.name, AToB, LENGTH(COLLECT(s)) AS BToA ---- Here we start with our list of people and then find all the combinations where personA has sent an email that's been received by personB. If we execute just the first half of that we can see the email sent/received combinations: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"') MATCH personA-[s:SENT]->email<-[r:RECEIVED]-personB WHERE personA <> personB RETURN personA, personB, email ---- [source,text] ---- ==> +---------------------------------------------------------------------------------------------------------+ ==> | personA | personB | email | ==> +---------------------------------------------------------------------------------------------------------+ ==> | Node[4]{name:"Mark"} | Node[5]{name:"Jim"} | Node[1]{name:"Email 1",title:"Some stuff"} | ==> | Node[4]{name:"Mark"} | Node[5]{name:"Jim"} | Node[2]{name:"Email 2",title:"Absolutely irrelevant"} | ==> | Node[5]{name:"Jim"} | Node[4]{name:"Mark"} | Node[3]{name:"Email 3",title:"Something else"} | ==> | Node[4]{name:"Mark"} | Node[6]{name:"Alistair"} | Node[1]{name:"Email 1",title:"Some stuff"} | ==> +---------------------------------------------------------------------------------------------------------+ ---- In the second half of the query we find the inverse relationships but we also want to indicate if one person hasn't sent any emails to the other one (e.g. Alistair to Mark) which is why I brought in the optional 'SENT' relationship. If we run that we get the following: [source,text] ---- ==> +-------------------------------------------+ ==> | personA.name | personB.name | AToB | BToA | ==> +-------------------------------------------+ ==> | "Jim" | "Mark" | 1 | 2 | ==> | "Mark" | "Alistair" | 1 | 0 | ==> | "Mark" | "Jim" | 2 | 1 | ==> +-------------------------------------------+ ---- It's a bit better in that we've now got the emails sent by pairs of people on the same row but we still have duplication e.g. Jim/Mark and Mark/Jim show as separate rows even though they show the same information. We also won't see a row if Person A hasn't sent an email to PersonB even if Person B has emailed Person A. At this stage I was a bit stuck but https://twitter.com/maxdemarzi[Max] pointed out that we could use the http://docs.neo4j.org/chunked/milestone/query-match.html#match-all-shortest-paths[all shortest paths algorithm] to solve the problem. We started out with the following query: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name: "Jim" name: "Alistair"') WITH personA,personB MATCH p = AllShortestPaths(personA-[:SENT|RECEIVED*..2]-personB) RETURN p ---- which returns: [source,text] ---- ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | p | ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | [Node[4]{name:"Mark"}] | ==> | [Node[4]{name:"Mark"},:SENT[0] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[1] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:SENT[3] {},Node[2]{name:"Email 2",title:"Absolutely irrelevant"},:RECEIVED[4] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:RECEIVED[6] {},Node[3]{name:"Email 3",title:"Something else"},:SENT[5] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:SENT[0] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[2] {},Node[6]{name:"Alistair"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[1] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[4] {},Node[2]{name:"Email 2",title:"Absolutely irrelevant"},:SENT[3] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:SENT[5] {},Node[3]{name:"Email 3",title:"Something else"},:RECEIVED[6] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[1] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[2] {},Node[6]{name:"Alistair"}] | ==> | [Node[6]{name:"Alistair"},:RECEIVED[2] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> | [Node[6]{name:"Alistair"},:RECEIVED[2] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[1] {},Node[5]{name:"Jim"}] | ==> | [Node[6]{name:"Alistair"}] | ==> +------------------------------------------------------------------------------------------------------------------------------+ ---- Since we're only really interested in the emails that people have sent to each other we'll narrow down the result set to only include those paths: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name: "Jim" name: "Alistair"') WITH personA,personB MATCH p = AllShortestPaths(personA-[:SENT|RECEIVED*..2]-personB) WHERE ANY (x IN relationships(p) WHERE TYPE(x)= 'SENT') RETURN p ---- [source,text] ---- ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | p | ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | [Node[4]{name:"Mark"},:SENT[0] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[1] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:SENT[3] {},Node[2]{name:"Email 2",title:"Absolutely irrelevant"},:RECEIVED[4] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:RECEIVED[6] {},Node[3]{name:"Email 3",title:"Something else"},:SENT[5] {},Node[5]{name:"Jim"}] | ==> | [Node[4]{name:"Mark"},:SENT[0] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[2] {},Node[6]{name:"Alistair"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[1] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[4] {},Node[2]{name:"Email 2",title:"Absolutely irrelevant"},:SENT[3] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:SENT[5] {},Node[3]{name:"Email 3",title:"Something else"},:RECEIVED[6] {},Node[4]{name:"Mark"}] | ==> | [Node[6]{name:"Alistair"},:RECEIVED[2] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> +------------------------------------------------------------------------------------------------------------------------------+ ---- There's currently some duplication because we have paths going both ways between people included. e.g. [source,text] ---- [Node[4]{name:"Mark"},:SENT[0] {},Node[1]{name:"Email 1",title:"Some stuff"},:RECEIVED[1] {},Node[5]{name:"Jim"}] ---- and: [source,text] ---- [Node[5]{name:"Jim"},:RECEIVED[1] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] ---- refer to the same thing. We'll filter by keeping the starting node which has a higher node id - we could use any property to do this comparison but id will do: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name: "Jim" name: "Alistair"') WITH personA,personB MATCH p = AllShortestPaths(personA-[:SENT|RECEIVED*..2]-personB) WHERE ANY (x IN relationships(p) WHERE TYPE(x)= 'SENT') AND ID(head(nodes(p))) > ID(head((tail(tail(nodes(p)))))) RETURN p ---- [source,text] ---- ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | p | ==> +------------------------------------------------------------------------------------------------------------------------------+ ==> | [Node[5]{name:"Jim"},:RECEIVED[1] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:RECEIVED[4] {},Node[2]{name:"Email 2",title:"Absolutely irrelevant"},:SENT[3] {},Node[4]{name:"Mark"}] | ==> | [Node[5]{name:"Jim"},:SENT[5] {},Node[3]{name:"Email 3",title:"Something else"},:RECEIVED[6] {},Node[4]{name:"Mark"}] | ==> | [Node[6]{name:"Alistair"},:RECEIVED[2] {},Node[1]{name:"Email 1",title:"Some stuff"},:SENT[0] {},Node[4]{name:"Mark"}] | ==> +------------------------------------------------------------------------------------------------------------------------------+ ---- Now we just need to do a bit more manipulation of these paths and we have exactly what we need: [source,cypher] ---- START personA = node:node_auto_index('name:"Mark" name:"Jim" name:"Alistair"'), personB = node:node_auto_index('name:"Mark" name: "Jim" name: "Alistair"') WITH personA,personB MATCH p = AllShortestPaths(personA-[:SENT|RECEIVED*..2]-personB) WHERE ANY (x IN relationships(p) WHERE TYPE(x)= 'SENT') AND ID(head(nodes(p))) > ID(head((tail(tail(nodes(p)))))) RETURN HEAD(NODES(p)) AS personA, HEAD((TAIL(TAIL(NODES(p))))) AS personB, LENGTH(FILTER(y IN COLLECT(HEAD(RELS(p))): TYPE(y)= 'SENT')) as AToB, LENGTH(FILTER(y IN COLLECT(HEAD(TAIL(RELS(p)))): TYPE(y)= 'SENT')) as BToA ---- What we've done here is count the number of 'SENT' relationships from person A's side of the path and then do the same for person B's side of the path. There's currently no way to do slicing of a collection in cypher otherwise we wouldn't need those nested calls to TAIL! We do however get the result we want: [source,text] ---- ==> +---------------------------------------------------------------+ ==> | personA | personB | AToB | BToA | ==> +---------------------------------------------------------------+ ==> | Node[6]{name:"Alistair"} | Node[4]{name:"Mark"} | 0 | 1 | ==> | Node[5]{name:"Jim"} | Node[4]{name:"Mark"} | 1 | 2 | ==> +---------------------------------------------------------------+ ---- I have no idea how well this query would perform for any significantly sized data set but it's an interesting query nonetheless.

neo4jcypher-aggregating-relationships-within-a-path

https://markhneedham.com/blog/2013/06/27/neo4jcypher-aggregating-relationships-within-a-path

2013-06-29 08:44:00

Vagrant 1.2.2: `[]': can't convert Symbol into Integer (TypeError)/The following settings don't exist

As I mentioned in my previous post I've been playing around with Vagrant for the past couple of days and I was trying to adapt a https://gist.github.com/nfisher/4982076[Vagrantfile that Nathan created] a few months ago to do what I wanted. I'm using Vagrant 1.2.2 and I started out with the following Vagrantfile: [source,ruby] ---- Vagrant.configure("2") do |config| config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" config.vm.define :neo01 do |neo| neo.vm.network :hostonly, "192.168.33.101" neo.vm.forward_port 8080, 4569 end end ---- Unfortunately a 'vagrant up' doesn't quite work as expected: [source,bash] ---- $ vagrant up /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/plugins/kernel_v2/config/vm.rb:146:in `[]': can't convert Symbol into Integer (TypeError) from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/plugins/kernel_v2/config/vm.rb:146:in `network' from /Users/markneedham/projects/support/haproxy/Vagrantfile:19:in `block (2 levels) in <top (required)>' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/v2/loader.rb:37:in `call' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/v2/loader.rb:37:in `load' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/loader.rb:104:in `block (2 levels) in load' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/loader.rb:98:in `each' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/loader.rb:98:in `block in load' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/loader.rb:95:in `each' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/config/loader.rb:95:in `load' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:329:in `machine' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/plugin/v2/command.rb:131:in `block in with_target_vms' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/plugin/v2/command.rb:164:in `call' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/plugin/v2/command.rb:164:in `block in with_target_vms' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/plugin/v2/command.rb:163:in `map' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/plugin/v2/command.rb:163:in `with_target_vms' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/plugins/commands/up/command.rb:42:in `block in execute' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:206:in `block (2 levels) in batch' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:204:in `tap' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:204:in `block in batch' from <internal:prelude>:10:in `synchronize' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:203:in `batch' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/plugins/commands/up/command.rb:41:in `execute' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/cli.rb:46:in `execute' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/lib/vagrant/environment.rb:467:in `cli' from /Applications/Vagrant/embedded/gems/gems/vagrant-1.2.2/bin/vagrant:84:in `<top (required)>' from /Applications/Vagrant/bin/../embedded/gems/bin/vagrant:23:in `load' from /Applications/Vagrant/bin/../embedded/gems/bin/vagrant:23:in `<main>' ---- The problem line is 'neo.vm.network :hostonly, "192.168.33.101"' which I learnt is because https://github.com/mitchellh/vagrant/issues/1628[the way you setup networking has changed slightly between the versions]. We now need something like this: [source,ruby] ---- Vagrant.configure("2") do |config| config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" config.vm.define :neo01 do |neo| neo.vm.network :private_network, ip: "192.168.33.101" neo.vm.forward_port 8080, 4569 end end ---- If we run 'vagrant up' again we'll see that error has been removed and we have a new one! [source,bash] ---- $ vagrant up Bringing machine 'neo01' up with 'virtualbox' provider... There are errors in the configuration of this machine. Please fix the following errors and try again: vm: * The following settings don't exist: forward_port ---- It turns out the way that we do port forwarding has also changed. Annoyingly if you google 'vagrant port forwarding' it still points you to the http://docs-v1.vagrantup.com/v1/docs/getting-started/ports.html[old documentation] rather than the http://docs.vagrantup.com/v2/getting-started/networking.html[newer one]. We need to change our code to the following: [source,ruby] ---- Vagrant.configure("2") do |config| config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" config.vm.define :neo01 do |neo| neo.vm.network :private_network, ip: "192.168.33.101" neo.vm.network :forwarded_port, host: 4569, guest: 8080 end end ---- If we run 'vagrant up' now it's much happier: [source,bash] ---- $ vagrant up Bringing machine 'neo01' up with 'virtualbox' provider... [neo01] Setting the name of the VM... [neo01] Clearing any previously set forwarded ports... ... ----

vagrant-1-2-2-cant-convert-symbol-into-integer-typeerrorthe-following-settings-dont-exist

https://markhneedham.com/blog/2013/06/29/vagrant-1-2-2-cant-convert-symbol-into-integer-typeerrorthe-following-settings-dont-exist

2013-06-29 07:38:35

Vagrant/Virtual Box: There was an error executing the following command with VBoxManage - Progress object failure: NS_ERROR_CALL_FAILED

I've been playing around with http://www.vagrantup.com/[Vagrant] a bit again lately and having installed it on a new machine was running into the following exception when I tried to run 'vagrant up' on a new virtual machine: [source,text] ---- ERROR vagrant: /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/driver/base.rb:292:in `block in execute' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/util/retryable.rb:17:in `retryable' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/driver/base.rb:282:in `execute' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/driver/version_4_2.rb:165:in `import' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/action/import.rb:15:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/builtin/handle_box_url.rb:38:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/action/check_accessible.rb:18:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/runner.rb:61:in `block in run' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/util/busy.rb:19:in `busy' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/runner.rb:61:in `run' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/builtin/call.rb:51:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/builtin/config_validate.rb:25:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/providers/virtualbox/action/check_virtualbox.rb:17:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/warden.rb:34:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/builder.rb:109:in `call' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/runner.rb:61:in `block in run' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/util/busy.rb:19:in `busy' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/action/runner.rb:61:in `run' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/machine.rb:129:in `action' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/commands/up/command.rb:37:in `block in execute' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/plugin/v2/command.rb:182:in `block in with_target_vms' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/plugin/v2/command.rb:180:in `each' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/plugin/v2/command.rb:180:in `with_target_vms' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/plugins/commands/up/command.rb:32:in `execute' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/cli.rb:46:in `execute' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib/vagrant/environment.rb:406:in `cli' /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/bin/vagrant:60:in `<top (required)>' /Applications/Vagrant/bin/../embedded/gems/bin/vagrant:23:in `load' /Applications/Vagrant/bin/../embedded/gems/bin/vagrant:23:in `<main>' INFO interface: error: There was an error executing the following command with VBoxManage: ["import", "/Users/markneedham/.vagrant.d/boxes/precise32/virtualbox/box.ovf"] ---- I tried running the command directly against Virtual Box to see if that would tell me anything else but it didn't shed much light: [source,text] ---- $ VBoxManage import "/Users/markneedham/.vagrant.d/boxes/precise32/virtualbox/box.ovf" 0%...10%...20%...30%...40%...50%...60%...70%...80%...90%...100% Interpreting /Users/markneedham/.vagrant.d/boxes/precise32/virtualbox/box.ovf... OK. Disks: vmdisk1 85899345920 -1 http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized box-disk1.vmdk -1 -1 Virtual system 0: 0: Suggested OS type: "Ubuntu_64" (change with "--vsys 0 --ostype <type>"; use "list ostypes" to list all possible values) 1: Suggested VM name "precise64" (change with "--vsys 0 --vmname <name>") 2: Number of CPUs: 2 (change with "--vsys 0 --cpus <n>") 3: Guest memory: 384 MB (change with "--vsys 0 --memory <MB>") 4: Network adapter: orig NAT, config 3, extra slot=0;type=NAT 5: CD-ROM (disable with "--vsys 0 --unit 5 --ignore") 6: IDE controller, type PIIX4 (disable with "--vsys 0 --unit 6 --ignore") 7: IDE controller, type PIIX4 (disable with "--vsys 0 --unit 7 --ignore") 8: SATA controller, type AHCI (disable with "--vsys 0 --unit 8 --ignore") 9: Hard disk image: source image=box-disk1.vmdk, target path=/Users/markneedham/VirtualBox VMs/precise64/box-disk1.vmdk, controller=8;channel=0 (change target path with "--vsys 0 --unit 9 --disk path"; disable with "--vsys 0 --unit 9 --ignore") 0%... Progress object failure: NS_ERROR_CALL_FAILED ---- That gave me enough information to Google my way to https://github.com/mitchellh/vagrant/issues/1847[an issue on github] where it was suggested that this was a problem with VirtualBox 4.2.14 and that downgrading with 4.2.10 would more profitable. As I'd downloaded the latest VirtualBox the version I had was indeed 4.2.14: [source,bash] ---- $ VBoxManage --version 4.2.14r86644 ---- </p> I grabbed https://www.virtualbox.org/wiki/Download_Old_Builds_4_2[an older copy] of Virtual Box and that seemed to do the trick although I later ran into a problem which I foolishly haven't kept the stack trace of and found that upgrading my vagrant version solved that.<p> So to summarise, my current versions of vagrant and Virtual Box which work splendidly: [source,bash] ---- $ vagrant -v Vagrant version 1.2.2 $ VBoxManage -version 4.2.10r84104 ---- YMMV and all that!

vagrantvirtual-box-there-was-an-error-executing-the-following-command-with-vboxmanage-progress-object-failure-ns_error_call_failed

https://markhneedham.com/blog/2013/06/29/vagrantvirtual-box-there-was-an-error-executing-the-following-command-with-vboxmanage-progress-object-failure-ns_error_call_failed

2013-06-19 05:32:50

neo4j: WrappingNeoServerBootstrapper and the case of the /webadmin 404

When people first use neo4j they frequently start out by http://docs.neo4j.org/chunked/stable/tutorials-java-embedded.html[embedding it in a Java application] but eventually they want to explore the graph in a more visual way. One simple way to do this is to start neo4j in server mode and use the web console. Our initial code might read like this: [source,java] ---- public class GraphMeUp { public static void main(String[] args) { GraphDatabaseService graphDb = new EmbeddedGraphDatabase("/path/to/data/graph.db"); } } ---- or: [source,java] ---- public class GraphMeUp { public static void main(String[] args) { GraphDatabaseService graphDb = new GraphDatabaseFactory(). newEmbeddedDatabaseBuilder("/path/to/data/graph.db"). newGraphDatabase(); } } ---- And to start our graph up in server mode we can use the +++<cite>+++http://components.neo4j.org/neo4j-server/1.9/apidocs/org/neo4j/server/WrappingNeoServerBootstrapper.html[WrappingNeoServerBootstrapper]+++</cite>+++ class which is packaged in neo4j-server so we first need to add that dependency: [source,xml] ---- <dependency> <groupId>org.neo4j.app</groupId> <artifactId>neo4j-server</artifactId> <version>1.9</version> </dependency> ---- [source,java] ---- public class GraphMeUp { public static void main(String[] args) { GraphDatabaseService graphDb = new GraphDatabaseFactory(). newEmbeddedDatabaseBuilder("/path/to/data/graph.db"). newGraphDatabase(); new WrappingNeoServerBootstrapper((GraphDatabaseAPI)graphDb).start(); } } ---- If we then browse to http://localhost:7474/webadmin/ we'll be greeted by a 404 error: [source,text] ---- HTTP ERROR 404 Problem accessing /webadmin/. Reason: Not Found Powered by Jetty:// ---- sad panda :( Until I came across http://stackoverflow.com/questions/8111959/use-wrappingneoserverbootstrapper-with-spring-data-neo4j[this post on StackOverflow by Michael] I didn't realise that there's actually another dependency that we need to include to get the web admin goodness! To get things worked as we'd expect we need to include the following dependency: ~~~xml +++<dependency>++++++<groupId>+++org.neo4j.app+++</groupId>+++ +++<artifactId>+++neo4j-server+++</artifactId>+++ +++<version>+++1.9+++</version>+++ +++<type>+++jar+++</type>+++ +++<classifier>+++static-web+++</classifier>+++ +++<scope>+++compile+++</scope>++++++</dependency>+++ ~~~ I hadn't come across the +++<cite>+++classifier+++</cite>+++ attribute before but what this does is include the following JAR: ~~~bash $ ls -alh ~/.m2/repository/org/neo4j/app/neo4j-server/1.9/neo4j-server-1.9-static-web.jar -rw-r--r-- 1 markhneedham staff 3.5M 17 Jun 11:28 /Users/markhneedham/.m2/repository/org/neo4j/app/neo4j-server/1.9/neo4j-server-1.9-static-web.jar ~~~ If we run our code again we should see the bright and cheery web admin interface and all is good with the world.

neo4j-wrappingneoserverbootstrapper-and-the-case-of-the-webadmin-404

https://markhneedham.com/blog/2013/06/19/neo4j-wrappingneoserverbootstrapper-and-the-case-of-the-webadmin-404

2013-06-26 15:23:14

Unix/awk: Extracting substring using a regular expression with capture groups

A couple of years ago I http://www.markhneedham.com/blog/2011/09/12/gawk-getting-story-numbers-from-git-commit-messages/[wrote a blog post] explaining how I'd used http://www.gnu.org/software/gawk/[GNU awk] to extract story numbers from git commit messages and I wanted to do a similar thing today to extract some node ids from a file. My eventual solution looked like this: [source,bash] ---- $ echo "mark #1000" | gawk '{ match($0, /#([0-9]+)/, arr); if(arr[1] != "") print arr[1] }' 1000 ---- But in the comments an alternative approach was suggested which used the Mac version of awk and the RSTART and RLENGTH global variables which get set when a match is found: [source,bash] ---- $ echo "mark #1000" | awk 'match($0, /#[0-9]+/) { print substr( $0, RSTART, RLENGTH )}' #1000 ---- Unfortunately http://stackoverflow.com/questions/2957684/awk-access-captured-group-from-line-pattern[Mac awk doesn't seem to capture groups] so as you can see it includes the # character which we don't actually want. In this instance it wasn't such a big deal but it was more annoying for the node id extraction that I was trying to do: [source,bash] ---- $ head -n 5 log.txt Command[27716, Node[7825340,used=true,rel=14547348,prop=31734662]] Command[27716, Node[7825341,used=true,rel=14547349,prop=31734665]] Command[27716, Node[7825342,used=true,rel=14547350,prop=31734668]] Command[27716, Node[7825343,used=true,rel=14547351,prop=31734671]] ---- [source,bash] ---- $ head -n 5 log.txt | awk 'match($0, /Node\[([^,]+)/) { print substr( $0, RSTART, RLENGTH )}' Node[7825340 Node[7825341 Node[7825342 Node[7825343 Node[7825336 ---- I ended up having to +++<cite>+++brew install gawk+++</cite>+++ and using a variation of the +++<cite>+++gawk+++</cite>+++ command I mentioned at the beginning of this post: [source,bash] ---- $ head -n 5 log.txt | gawk 'match($0, /Node\[([^,]+)/, arr) { print arr[1]}' 7825340 7825341 7825342 7825343 7825336 ----

unixawk-extracting-substring-using-a-regular-expression-with-capture-groups

https://markhneedham.com/blog/2013/06/26/unixawk-extracting-substring-using-a-regular-expression-with-capture-groups

2013-06-09 16:57:35

neo4j.rb HA: NameError: cannot load Java class org.neo4j.graphdb.factory.HighlyAvailableGraphDatabaseFactory

https://github.com/andreasronge/neo4j[neo4.rb] is a JRuby gem that allows you to create an http://docs.neo4j.org/chunked/stable/tutorials-java-embedded.html[embedded neo4j database] and last week I was working out how to setup a neo4j 1.8.2 HA cluster using the gem. There is an example showing how to https://github.com/andreasronge/neo4j/tree/master/example/ha-cluster[create a HA cluster using neo4j.rb] so I thought I could adapt that to do what I wanted. I had the following Gemfile: [source,ruby] ---- source 'http://rubygems.org' gem 'neo4j', '2.2.4' gem 'neo4j-community', '1.8.2' gem 'neo4j-advanced', '1.8.2' gem 'neo4j-enterprise', '1.8.2' ---- And the following code copied from https://github.com/andreasronge/neo4j/blob/master/example/ha-cluster/myapp.rb[the example] to start up the cluster: [source,ruby] ---- require "rubygems" require "bundler" require 'fileutils' require 'neo4j' def start(machine_id) # override this default config with this machine configuration Neo4j.config['enable_ha'] = true Neo4j.config['ha.server_id'] = machine_id Neo4j.config['ha.server'] = "localhost:600#{machine_id}" Neo4j.config['ha.pull_interval'] = '500ms' Neo4j.config['ha.discovery.enabled'] = false other_machines = [1,2,3].map{|id| "localhost:500#{id}"}.join(',') puts "ha.initial_hosts: #{other_machines}" Neo4j.config['ha.initial_hosts'] = other_machines Neo4j.config['ha.cluster_server'] = "localhost:500#{machine_id}" Neo4j.config[:storage_path] = "db/neo#{machine_id}" Neo4j.start end ---- As per the example's instructions I started up an irb session and tried to start up an instance: [source,ruby] ---- $ bundle exec install $ bundle exec irb irb(main):001:0> require 'myapp' => true irb(main):002:0> start 1 ha.initial_hosts: localhost:5001,localhost:5002,localhost:5003 I, [2013-06-09T17:23:09.110000 #33848] INFO -- : starting Neo4j in HA mode, machine id: 1 at localhost:6001 db /Users/markhneedham/projects/neo4j-rb-ha/db/neo1 NameError: cannot load Java class org.neo4j.graphdb.factory.HighlyAvailableGraphDatabaseFactory from org/jruby/javasupport/JavaClass.java:1225:in `for_name' from org/jruby/javasupport/JavaUtilities.java:34:in `get_proxy_class' from file:/Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/jruby.jar!/jruby/java/java_package_module_template.rb:4:in `const_missing' from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:188:in `start_ha_graph_db' from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:62:in `start' from org/jruby/ext/thread/Mutex.java:149:in `synchronize' from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:53:in `start' from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j/neo4j.rb:41:in `start' from /Users/markhneedham/projects/neo4j-rb-ha/myapp.rb:21:in `start' from (irb):2:in `evaluate' from org/jruby/RubyKernel.java:1066:in `eval' from org/jruby/RubyKernel.java:1392:in `loop' from org/jruby/RubyKernel.java:1174:in `catch' from org/jruby/RubyKernel.java:1174:in `catch' from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/bin/irb:13:in `(root)' ---- A quick scan of the neo4j code indicated that the class +++<cite>+++HighlyAvailableGraphDatabaseFactory+++</cite>+++ didn't actually exist in any of the neo4j 1.8.2 jars and https://twitter.com/maxdemarzi[Max] then pointed out the https://github.com/andreasronge/neo4j/blob/master/CHANGELOG[neo4j.rb change log] which indicated that the clustering example was based around a neo4j 1.9 cluster. If we want to create a neo4j 1.8 cluster then we need to tweak the settings a bit. The instructions are available from https://github.com/andreasronge/neo4j/commit/022d93909739245703d2321761de0f2218f6184c[an earlier revision of the neo4j.rb] repository but I've cloned the repository and created a https://github.com/mneedham/neo4j-1/tree/1.8HA/example/ha-cluster[1.8HA tag] for future reference. Essentially we'd need to revert back to the '2.2.1' version of the neo4j.rb gem and then run a script to startup some Zookeeper instances before following a similar process as described at the beginning of this post.

neo4j-rb-ha-nameerror-cannot-load-java-class-org-neo4j-graphdb-factory-highlyavailablegraphdatabasefactory

https://markhneedham.com/blog/2013/06/09/neo4j-rb-ha-nameerror-cannot-load-java-class-org-neo4j-graphdb-factory-highlyavailablegraphdatabasefactory

2013-06-09 23:10:34

Unix: find, xargs, zipinfo and the 'caution: filename not matched:' error

As I mentioned http://www.markhneedham.com/blog/2013/06/09/neo4j-rb-ha-nameerror-cannot-load-java-class-org-neo4j-graphdb-factory-highlyavailablegraphdatabasefactory/[in my previous post] last week I needed to scan all the jar files included with the neo4j-enterprise gem and I started out by finding out where it's located on my machine: [source,bash] ---- $ bundle show neo4j-enterprise /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java ---- I then thought I could get a list of all the jar files using +++<cite>+++http://unixhelp.ed.ac.uk/CGI/man-cgi?find[find]+++</cite>+++ and pipe it into +++<cite>+++http://linux.about.com/library/cmd/blcmdl1_zipinfo.htm[zipinfo]+++</cite>+++ via http://linux.die.net/man/1/xargs[xargs] to get all the file names and then search for +++<cite>+++HighlyAvailableGraphDatabaseFactory+++</cite>+++: Unfortunately when I tried that it didn't quite work: [source,bash] ---- $ cd /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java/lib/neo4j-enterprise/jars/ $ find . -iname "*.jar" | xargs zipinfo caution: filename not matched: ./lib/neo4j-enterprise/jars/logback-classic-0.9.30.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/logback-core-0.9.30.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/neo4j-backup-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/neo4j-com-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/neo4j-consistency-check-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/neo4j-ha-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/neo4j-udc-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/server-api-1.8.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/slf4j-api-1.6.2.jar caution: filename not matched: ./lib/neo4j-enterprise/jars/zookeeper-3.3.2.jar ---- I switched 'zipinfo' to 'echo' to see what was going on which resulted in the following output: [source,bash] ---- $ find . -iname "*.jar" | xargs echo ./log4j-1.2.16.jar ./logback-classic-0.9.30.jar ./logback-core-0.9.30.jar ./neo4j-backup-1.8.2.jar ./neo4j-com-1.8.2.jar ./neo4j-consistency-check-1.8.2.jar ./neo4j-ha-1.8.2.jar ./neo4j-udc-1.8.2.jar ./org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar ./server-api-1.8.2.jar ./slf4j-api-1.6.2.jar ./zookeeper-3.3.2.jar ---- As I understand it, xargs expects arguments to be separated by a space and I thought it would apply the command to each argument individually but it seemed to be including the space as part of the file name. I've previously used the '-n' flag to +++<cite>+++xargs+++</cite>+++ to explicitly tell it to call the corresponding command with one argument at a time and that seemed to do the trick: [source,bash] ---- $ find . -iname "*.jar" | xargs -n1 zipinfo Archive: ./log4j-1.2.16.jar 481535 bytes 346 files -rw---- 2.0 fat 3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/ -rw---- 2.0 fat 11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE -rw---- 2.0 fat 160 bl defN 30-Mar-10 23:14 META-INF/NOTICE -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/maven/ -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/ ... ---- Of course to solve this particular we don't actually need to use +++<cite>+++find+++</cite>+++ and +++<cite>+++xargs+++</cite>+++ since we can just call +++<cite>+++zipinfo+++</cite>+++ http://rubenerd.com/caution-filename-not-matched-unzip-error/[with the wildcard match]: [source,bash] ---- $ zipinfo \*.jar Archive: log4j-1.2.16.jar 481535 bytes 346 files -rw---- 2.0 fat 3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/ -rw---- 2.0 fat 11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE -rw---- 2.0 fat 160 bl defN 30-Mar-10 23:14 META-INF/NOTICE -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/maven/ -rw---- 2.0 fat 0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/ -rw---- ... ---- I'm curious why +++<cite>+++xargs+++</cite>+++ didn't work as I expected it to though - have I just misremembered its default behaviour or is something weird going on?

unix-find-xargs-zipinfo-and-the-caution-filename-not-matched-error

https://markhneedham.com/blog/2013/06/09/unix-find-xargs-zipinfo-and-the-caution-filename-not-matched-error

2013-06-09 14:02:27

neo4j/cypher 2.0: The CASE statement

I've been playing around with how you might model Premier League managers tenures at different clubs in neo4j and eventually decided on the following model: image::{{<siteurl>}}/uploads/2013/06/managers-tiff.png[Managers tiff,530] The date modelling is https://speakerdeck.com/vpacher/cloudeast-how-shutl-uses-neo4j-to-delivery-even-faster?slide=62[based on an approach I first came across in a shutl presentation] and is described in more detail in the http://docs.neo4j.org/chunked/snapshot/cypher-cookbook-path-tree.html#cookbook-return-partly-shared-path-ranges[docs]. I created a dummy data set with some made up appointments and dismissals and then tried to write a query to show me who was the manager for a team on a specific date. ~~~cypher CREATE (year2013 { name: "2013" }) CREATE (january2013 { name: "January" }) CREATE (january012013 { name: "1st" }) CREATE (january022013 { name: "2nd" }) CREATE (january032013 { name: "3rd" }) CREATE (january042013 { name: "4th" }) CREATE (january052013 { name: "5th" }) CREATE (chelsea { name: "Chelsea", type: "team" }) CREATE (joseMourinho { name: "Jose Mourinho"}) CREATE (mourinhoChelsea { name: "Mourinho tenure at Chelsea" }) CREATE (manUtd { name: "Manchester United", type: "team" }) CREATE (davidMoyes { name: "David Moyes"}) CREATE (davidMoyesUnited { name: "Moyes tenure at Manchester United" }) CREATE (year2013)-[:`January`]-(january2013) CREATE (january2013)-[:`01`]-(january012013) CREATE (january2013)-[:`02`]-(january022013) CREATE (january2013)-[:`03`]-(january032013) CREATE (january2013)-[:`04`]-(january042013) CREATE (january2013)-[:`05`]-(january052013) CREATE (january012013)-[:NEXT]-(january022013) CREATE (january022013)-[:NEXT]-(january032013) CREATE (january032013)-[:NEXT]-(january042013) CREATE (january042013)-[:NEXT]-(january052013) CREATE (mourinhoChelsea)-[:HIRED_ON {date: "January 1st 2013"}]\->(january012013) CREATE (mourinhoChelsea)-[:MANAGER]\->(joseMourinho) CREATE (mourinhoChelsea)-[:TEAM]\->(chelsea) CREATE (mourinhoChelsea)-[:FIRED_ON]\->(january032013) CREATE (davidMoyesUnited)-[:HIRED_ON {date: "January 2nd 2013"}]\->(january022013) CREATE (davidMoyesUnited)-[:MANAGER]\->(davidMoyes) CREATE (davidMoyesUnited)-[:TEAM]\->(manUtd) ~~~ ~~~cypher START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), date = node:node_auto_index(name="5th") MATCH date\<-[:NEXT*0..]-()\<-[hire:HIRED_ON]-tenure-[:MANAGER]\->manager, tenure-[:TEAM]\->team, tenure-[fired?:FIRED_ON]-dateFired RETURN team.name, manager.name, hire.date, dateFired ~~~ The query starts from January 5th, then gets all the previous dates and looks for a 'HIRED_ON' relationship and then follows that to get the manager and the team for which it applies to. We then traverse an optional 'FIRED_ON' relationship as well because we don't want to say a manager is currently at a club if they've been fired. It returns the following: ~~~text =\=> +----------------------------------------------------------------------------------+ =\=> | team.name | manager.name | hire.date | dateFired | =\=> +----------------------------------------------------------------------------------+ =\=> | "Manchester United" | "David Moyes" | "January 2nd 2013" | +++<null>+++| =\=> | "Chelsea" | "Jose Mourinho" | "January 1st 2013" | Node[5]{name:"3rd"} | =\=> +----------------------------------------------------------------------------------+ =\=> 2 rows ~~~ In this data set Jose Mourinho gets fired on the 3rd January so Chelsea shouldn't have a manager on the 5th January. One way to exclude him is to collect all the dates that our 'NEXT' relationship takes us to and then check if the 'dateFired' is in that collection. If it is then the manager has been fired and we shouldn't return them: ~~~cypher START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), startDate = node:node_auto_index(name="5th") MATCH startDate\<-[:NEXT*0..]-day WITH team, startDate, COLLECT(day) AS dates MATCH startDate\<-[:NEXT*0..]-day\<-[hire:HIRED_ON]-tenure-[:MANAGER]\->manager, tenure-[:TEAM]\->team, tenure-[?:FIRED_ON]-dateFired WHERE dateFired IS NULL OR NOT dateFired IN dates RETURN team.name, manager.name, hire.date, dateFired ~~~ That returns the following: ~~~text =\=> +----------------------------------------------------------------------+ =\=> | team.name | manager.name | hire.date | dateFired | =\=> +----------------------------------------------------------------------+ =\=> | "Manchester United" | "David Moyes" | "January 2nd 2013" | +++<null>+++| =\=> +----------------------------------------------------------------------+ =\=> 1 row ~~~ Unfortunately we now don't get a row for Chelsea because the WHERE clause filters Mourinho out. I couldn't think how to get around this so https://github.com/wfreeman[Wes] http://stackoverflow.com/questions/17004814/neo4j-cypher-modelling-football-managers-hired-fired-dates/17008425#17008425[suggested using neo4j 2.0] and the http://docs.neo4j.org/chunked/milestone/cypher-expressions.html[CASE] statement which makes this very easy. I eventually ended up with the following query which does the job: ~~~cypher START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), startDate = node:node_auto_index(name="2nd") MATCH startDate\<-[:NEXT*0..]-day WITH team, startDate, COLLECT(day) AS dates MATCH startDate\<-[:NEXT*0..]-day\<-[hire:HIRED_ON]-tenure-[:MANAGER]\->manager, tenure-[:TEAM]\->team, tenure-[?:FIRED_ON]\->dateFired RETURN team.name, CASE WHEN dateFired is null THEN manager.name WHEN dateFired IN dates THEN null ELSE manager.name END as managerName, CASE WHEN dateFired is null THEN hire.date WHEN dateFired IN dates THEN null ELSE hire.date END as hireDate ~~~ Here we've introduced the CASE statement which works pretty similarly to how the http://msdn.microsoft.com/en-us/library/ms181765.aspx[SQL CASE statement] works so it should be somehow familiar. That query returns the following: ~~~text =\=> +----------------------------------------------------------+ =\=> | team.name | managerName | hireDate | =\=> +----------------------------------------------------------+ =\=> | "Manchester United" | "David Moyes" | "January 2nd 2013" | =\=> | "Chelsea" | +++<null>+++| +++<null>+++| =\=> +----------------------------------------------------------+ =\=> 2 rows ~~~ which is exactly what we want. Now I need to import http://en.wikipedia.org/wiki/List_of_Premier_League_managers[a real data set] to see what it looks like!+++</null>++++++</null>++++++</null>++++++</null>+++

neo4jcypher-2-0-the-case-statement

https://markhneedham.com/blog/2013/06/09/neo4jcypher-2-0-the-case-statement

2013-06-30 13:13:14

Vagrant: Multi (virtual) machine with Puppet roles

I've been playing around with setting up a http://docs.neo4j.org/chunked/stable/ha-haproxy.html[neo4j cluster] using Vagrant and HAProxy and one thing I wanted to do was define two different roles for the HAProxy and neo4j machines. When I was working at http://www.uswitch.com/[uSwitch] http://junctionbox.ca/[Nathan] had solved a similar problem, but with AWS VMs, by defining the role in an environment variable in the VM's spin up script. In retrospect I think I might have been able to do that by using the http://docs.vagrantup.com/v2/provisioning/shell.html[shell provisioner] and calling that before the http://docs.vagrantup.com/v2/provisioning/puppet_apply.html[puppet provisioner] but Nathan, https://twitter.com/garethr[Gareth Rushgrove] and https://twitter.com/russbuelt[Gregor Russbuelt] suggested that using http://puppetlabs.com/puppet/related-projects/facter/[facter] might be better. When I initially looked at the 'Custom Facts' section of http://docs.vagrantup.com/v2/provisioning/puppet_apply.html[the docs] I thought it was only possible to set facts for the Vagrant file as a whole but you can actually do it on a per VM basis which is neat. I added a method called 'provision_as_role' to the 'Vagrant::Config::V2::Root' class: [source,ruby] ---- module Vagrant module Config module V2 class Root def provision_as_role(role) vm.provision :puppet do |puppet| puppet.manifests_path = "puppet/manifests" puppet.module_path = "puppet/modules" puppet.manifest_file = "base.pp" puppet.facter = { "role" => role.to_s } end end end end end end ---- and then passed in a role depending on the VM in my Vagrantfile: [source,ruby] ---- require File.join(File.dirname(__FILE__), 'lib', 'root.rb') Vagrant.configure("2") do |config| config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" config.vm.define :neo01 do |neo| neo.vm.hostname = "neo01" neo.vm.network :private_network, ip: "192.168.33.101" neo.provision_as_role :neo end config.vm.define :lb01 do |lb| lb.vm.hostname = "lb01" lb.vm.network :private_network, ip: "192.168.33.104" lb.provision_as_role :lb end end ---- We can now access the variable '$role' in our puppet code which I used like so: +++<cite>+++puppet/base.pp+++</cite>+++ [source,puppet] ---- class all_the_things { exec { 'apt-get update': command => '/usr/bin/apt-get update'; } package { 'curl': ensure => '7.22.0-3ubuntu4', } class { 'apt': } } node default { class { 'all_the_things': } class { $role: require => Class['all_the_things'] } } ---- The 'neo' and 'lb' classes look like this: [source,puppet] ---- class neo { class { 'java': version => '7u25-0~webupd8~1', } class { 'neo4j': require => Class['java'], } } ---- [source,puppet] ---- class lb { class { 'haproxy': } } ---- The full code is on https://github.com/mneedham/haproxy-neo4j[github] but it's behaving a bit weirdly in some scenarios so I'm still trying to get it properly working.

vagrant-multi-virtual-machine-with-puppet-roles

https://markhneedham.com/blog/2013/06/30/vagrant-multi-virtual-machine-with-puppet-roles

2013-06-30 22:53:14

Ruby: Calculating the orthodromic distance using the Haversine formula

As part of the http://www.markhneedham.com/blog/2013/06/30/leaflet-js-resizing-a-map-to-keep-a-circle-diameter-inside-it/[UI I'm building around my football stadiums data set] I wanted to calculate the distance from a football stadium to a point on the map in Ruby since http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html[cypher] doesn't currently return this value. I had the following cypher query to return the football stadiums near Westminster along with their lat/long values: [source,ruby] ---- lat, long, distance = ["51.55786291569685", "0.144195556640625", 10] query = " START node = node:geom('withinDistance:[#{lat}, #{long}, #{distance}]')" query << " RETURN node.name, node.team, node.lat, node.lon" rows = result["data"].map do |row| { :team => row[1], :stadium => row[0], :lat => row[2], :lon => row[3] } p rows ---- which returns the following: [source,ruby] ---- [{:team=>"Millwall", :stadium=>"The Den", :lat=>51.4859, :lon=>-0.050743}, {:team=>"Arsenal", :stadium=>"Emirates Stadium", :lat=>51.5549, :lon=>-0.108436}, {:team=>"Chelsea", :stadium=>"Stamford Bridge", :lat=>51.4816, :lon=>-0.191034}, {:team=>"Fulham", :stadium=>"Craven Cottage", :lat=>51.4749, :lon=>-0.221619}, {:team=>"Queens Park Rangers", :stadium=>"Loftus Road", :lat=>51.5093, :lon=>-0.232204}, {:team=>"Leyton Orient", :stadium=>"Brisbane Road", :lat=>51.5601, :lon=>-0.012551}] ---- In the neo4j spatial code the distance between two points is referred to as the 'orthodromic distance' but searching for that didn't come up with anything. However, I did eventually come across http://codingandweb.blogspot.co.uk/2012/04/calculating-distance-between-two-points.html[the following post] which referred to the http://en.wikipedia.org/wiki/Haversine_formula[Haversine formula] which is exactly what we want. There is a http://mathforum.org/library/drmath/view/51879.html[good explanation of the formula on the Ask Dr Math forum] which defines the formula like so: [source,text] ---- dlon = lon2 - lon1 dlat = lat2 - lat1 a = (sin(dlat/2))^2 + cos(lat1) * cos(lat2) * (sin(dlon/2))^2 c = 2 * atan2(sqrt(a), sqrt(1-a)) d = R * c ---- where: * R - the radius of the Earth * c - the great circle distance in radians * c - the great circle distance in the same units as R * lat1, lat2, lon1, lon2 - latitude and longitudes in radians To convert decimal degrees to radians we need to multiply the number of degrees by +++<cite>+++pi/180+++</cite>+++ radians/degree. The Ruby translation of that formula looks like this: [source,ruby] ---- def haversine(lat1, long1, lat2, long2) radius_of_earth = 6378.14 rlat1, rlong1, rlat2, rlong2 = [lat1, long1, lat2, long2].map { |d| as_radians(d)} dlon = rlong1 - rlong2 dlat = rlat1 - rlat2 a = power(Math::sin(dlat/2), 2) + Math::cos(rlat1) * Math::cos(rlat2) * power(Math::sin(dlon/2), 2) great_circle_distance = 2 * Math::atan2(Math::sqrt(a), Math::sqrt(1-a)) radius_of_earth * great_circle_distance end def as_radians(degrees) degrees * Math::PI/180 end def power(num, pow) num ** pow end ---- And if we change our initial code to use it: [source,ruby] ---- lat, long, distance = ["51.55786291569685", "0.144195556640625", 10] query = " START node = node:geom('withinDistance:[#{lat}, #{long}, #{distance}]')" query << " RETURN node.name, node.team, node.lat, node.lon" rows = result["data"].map do |row| { :team => row[1], :stadium => row[0], :distance => haversine(lat, long, row[2], row[3]).round(2), :lat => row[2], :lon => row[3] } p rows ---- which gives us the output we want: ~~~ruby [{:team\=>"Millwall", :stadium\=>"The Den", :distance\=>4.87, :lat\=>51.4859, :lon\=>-0.050743}, {:team\=>"Arsenal", :stadium\=>"Emirates Stadium", :distance\=>5.57, :lat\=>51.5549, :lon\=>-0.108436}, {:team\=>"Chelsea", :stadium\=>"Stamford Bridge", :distance\=>5.94, :lat\=>51.4816, :lon\=>-0.191034}, {:team\=>"Fulham", :stadium\=>"Craven Cottage", :distance\=>8.18, :lat\=>51.4749, :lon\=>-0.221619}, {:team\=>"Queens Park Rangers", :stadium\=>"Loftus Road", :distance\=>8.21, :lat\=>51.5093, :lon\=>-0.232204}, {:team\=>"Leyton Orient", :stadium\=>"Brisbane Road", :distance\=>9.33, :lat\=>51.5601, :lon\=>-0.012551}]~~~

ruby-calculating-the-orthodromic-distance-using-the-haversine-formula

https://markhneedham.com/blog/2013/06/30/ruby-calculating-the-orthodromic-distance-using-the-haversine-formula

2013-06-30 22:23:50

Leaflet JS: Resizing a map to keep a circle diameter inside it

I've been working on creating a UI to make searching for http://www.markhneedham.com/blog/2013/06/24/neo4j-spatial-indexing-football-stadiums-using-the-rest-api/[the football stadiums] that I wrote about last week a bit easier and I thought I'd give http://leafletjs.com/[Leaflet JS] a try. Leaflet is a Javascript library which was recommended to me by https://twitter.com/jasonneylon[Jason Neylon]) and can be used as a wrapper around Open Street Map. I started by creating a simple form where you could fill in a lat/long and distance and it would centre the map on that lat/long and show you a list of the stadiums within that diameter next to the map. Having done that I wanted to draw the diameter onto the map and then show the location of the stadiums which fitted inside the circle. I had the following code to centre the map and draw a circle: [source,javascript] ---- var distance = 10; $("#inputDistance").val(distance); var latLong=[51.505, -0.11398315429687499]; $("#inputLatLong").val(latLong) var map = L.map('map').setView(latLong,11); var layer = L.tileLayer('http://{s}.tile.cloudmade.com/e7b61e61295a44a5b319ca0bd3150890/997/256/{z}/{x}/{y}.png', { maxZoom: 18 }); layer.addTo(map); var currentDiameter = L.circle(latLong, distance * 1000); currentDiameter.addTo(map); var currentPositionMarker = L.marker([latLong[0], latLong[1]]); currentPositionMarker.addTo(map); ---- which creates this map: image::{{<siteurl>}}/uploads/2013/06/map.jpg[Map,300] I wanted to be able to change the diameter of the circle from the form and have it pick up more stadiums which I did with the following code: [source,javascript] ---- $("#inputDistance").change(function() { map.removeLayer(currentDiameter); currentDiameter = L.circle(currentPositionMarker.getLatLng(), $("#inputDistance").val() * 1000); currentDiameter.addTo(map); }); ---- I updated the diameter to be 16km and the map looked like this: image::{{<siteurl>}}/uploads/2013/06/map-diameter.jpg[Map diameter,300] It just about fits inside the map but setting it to anything higher means that the area of the diameter falls outside of the visible map which is annoying. I wanted to be able to resize the map when the circle changed in size and after a bit of browsing of the Leaflet code I came across a function called 'fitBounds' which lets us achieve this. I changed the code like so: [source,javascript] ---- $("#inputDistance").change(function() { map.removeLayer(currentDiameter); currentDiameter = L.circle(currentPositionMarker.getLatLng(), $("#inputDistance").val() * 1000); currentDiameter.addTo(map); map.fitBounds(currentDiameter.getBounds()); }); ---- Now if I change the distance the map resizes too: image::{{<siteurl>}}/uploads/2013/06/map-diameter-fixed.jpg[Map diameter fixed,300] Much better! The full code to do this reads like so: [source,javascript] ---- $(document).ready(function() { var distance = 10; $("#inputDistance").val(distance); var latLong=[51.505, -0.11398315429687499]; $("#inputLatLong").val(latLong) var map = L.map('map').setView(latLong,11); var layer = L.tileLayer('http://{s}.tile.cloudmade.com/e7b61e61295a44a5b319ca0bd3150890/997/256/{z}/{x}/{y}.png', { maxZoom: 18 }); layer.addTo(map); var currentDiameter = L.circle(latLong, distance * 1000); currentDiameter.addTo(map); var currentPositionMarker = L.marker([latLong[0], latLong[1]]); currentPositionMarker.addTo(map); $("#inputDistance").change(function() { map.removeLayer(currentDiameter); currentDiameter = L.circle(currentPositionMarker.getLatLng(), $("#inputDistance").val() * 1000); currentDiameter.addTo(map); map.fitBounds(currentDiameter.getBounds()); }); }); ---- The https://github.com/mneedham/neo4j-football-stadiums[code for this is all on github] although I've refactored it a bit now so it doesn't look exactly like this. I tried to put it on http://jsfiddle.net/[jsfiddle] as well but it didn't seem to work very well so screenshots it is!

leaflet-js-resizing-a-map-to-keep-a-circle-diameter-inside-it

https://markhneedham.com/blog/2013/06/30/leaflet-js-resizing-a-map-to-keep-a-circle-diameter-inside-it

2013-06-06 22:36:04

The Affect Heuristic

In my continued reading of Daniel Kahneman's http://www.amazon.co.uk/Thinking-Fast-Slow-Daniel-Kahneman/dp/0141033576/ref=sr_1_1?ie=UTF8&qid=1370274373&sr=8-1&keywords=thinking+fast+and+slow[Thinking Fast and Slow] I've reached the section which talks about *the affect heuristic* which seems particularly applicable to the technical decisions that we make. ____ The dominance of conclusions over arguments is most pronounced where emotions are involved. The psychologist Paul Slovic has proposed an affect heuristic in which *people let their likes and dislikes determine their beliefs about the world*. ____ The way I've seen this heuristic coming into play in the software world is when we do an 'objective' overview of the technical tools/options that we could use to solve a particular problem. We may do this by coming up with a list of advantages/disadvantages for each technology but the way we come up with this will probably be influenced by which of the technologies we prefer. We'll therefore place strong emphasis on the advantages of a technology and not think too much of disadvantages or work arounds that we have to implement. For example if Clojure were the technology in question then as an advocate of Clojure you might focus on the reduced lines of code and benefits of the functional way of programming and place less emphasis on the learning curve that new team members will have to overcome. Equally if you weren't a fan of Clojure then you'd do the opposite. I covered similar ground in http://www.markhneedham.com/blog/2013/02/28/compatible-opinions-confirmation-bias/[a post I wrote a few months ago] about compatible opinions where I suggested people used confirmation bias to back up their own opinions. I think the affect heuristic is slightly different though because it applies even when we think we're being impartial in our judgement. When I read things I like to try and think what action I should be taking as a result of learning new information. In this case I think the take away is to be more self aware than usual when talking about things we're passionate about. One way to achieve that could be to run our opinions via someone who is knowledgeable in the subject area but is less emotionally involved. It'd be interesting to see whether this resonates with others as well and how you handle it.

the-affect-heuristic

https://markhneedham.com/blog/2013/06/06/the-affect-heuristic

2013-06-24 07:17:15

neo4j Spatial: Indexing football stadiums using the REST API

Late last week my colleague https://twitter.com/peterneubauer[Peter] wrote up some documentation about http://neo4j.github.io/spatial/#spatial-server-plugin[creating spatial indexes in neo4j via HTTP], something I hadn't realised was possible until then. I previously wrote about http://www.markhneedham.com/blog/2013/03/10/neo4jcypher-finding-football-stadiums-near-a-city-using-spatial/[indexing football stadiums using neo4j spatial] but the annoying thing about the approach I described was that I was using neo4j in http://docs.neo4j.org/chunked/stable/tutorials-java-embedded.html[embedded mode] which restricts you to using a JVM language. The rest of my code is in Ruby so I thought I'd translate that code. To recap, I'm parsing a CSV file of football stadiums that I downloaded from http://www.doogal.co.uk/FootballStadiums.php[Chris Bell's blog] which looks like this: [source,text] ---- Name,Team,Capacity,Latitude,Longitude "Adams Park","Wycombe Wanderers",10284,51.6306,-0.800299 "Almondvale Stadium","Livingston",10122,55.8864,-3.52207 "Amex Stadium","Brighton and Hove Albion",22374,50.8609,-0.08014 ---- The code to process the file and index the stadiums in neo4j is https://github.com/mneedham/neo4j-football-stadiums/blob/master/create_stadiums.rb[as follows] (and is essentially a translation of the +++<cite>+++https://github.com/neo4j/spatial/blob/413317048eee7c2d3b25950d361634fc20c238d2/src/test/java/org/neo4j/gis/spatial/SpatialPluginFunctionalTest.java#L238[find_geometries_within_distance_using_cypher]+++</cite>+++ test): [source,ruby] ---- require 'csv' require 'httparty' require 'json' HTTParty.post("http://localhost:7474/db/data/ext/SpatialPlugin/graphdb/addSimplePointLayer", :body => { :layer => 'geom', :lat => 'lat', :lon => 'lon' }.to_json, :headers => { 'Content-Type' => 'application/json' } ) HTTParty.post("http://localhost:7474/db/data/index/node", :body => { :name => 'geom', :config => { :provider => 'spatial', :geometry_type => 'point', :lat => 'lat', :lon => 'lon' } }.to_json, :headers => { 'Content-Type' => 'application/json' } ) contents = CSV.read(File.join(File.dirname(__FILE__), 'data', 'stadiums.csv')) contents.shift contents.each do |row| name, team, capacity, lat, long = row node_id = HTTParty.post("http://localhost:7474/db/data/node", :body => { :lat => lat.to_f, :lon => long.to_f, :name => name, :team => team, :capacity => capacity }.to_json, :headers => { 'Content-Type' => 'application/json' } )['self'].split("/")[-1] HTTParty.post("http://localhost:7474/db/data/index/node/geom", :body => { :key => 'dummy', :value => 'dummy', :uri => "http://localhost:7474/db/data/node/#{node_id}"}.to_json, :headers => { 'Content-Type' => 'application/json' } ) end ---- One change from the previous version is that I'm not indexing the stadiums using point based geometry rather than wkt. If we want to find the number of stadiums within 10 km of Centre Point in London we'd write the following query: [source,cypher] ---- START node = node:geom('withinDistance:[51.521348,-0.128113, 10.0]') RETURN node.name, node.team; ---- [source,text] ---- ==> +--------------------------------------------+ ==> | node.name | node.team | ==> +--------------------------------------------+ ==> | "Emirates Stadium" | "Arsenal" | ==> | "Stamford Bridge" | "Chelsea" | ==> | "The Den" | "Millwall" | ==> | "Loftus Road" | "Queens Park Rangers" | ==> | "Craven Cottage" | "Fulham" | ==> | "Brisbane Road" | "Leyton Orient" | ==> +--------------------------------------------+ ==> 6 rows ---- I have https://github.com/mneedham/neo4j-football-stadiums[put the code on github] in case you're interested in playing around with it.

neo4j-spatial-indexing-football-stadiums-using-the-rest-api

https://markhneedham.com/blog/2013/06/24/neo4j-spatial-indexing-football-stadiums-using-the-rest-api

2013-06-15 10:28:28

Java: Finding/Setting JDK/$JAVA_HOME on Mac OS X

As long as I've been using a Mac I always understood that if you needed to set +++<cite>+++$JAVA_HOME+++</cite>+++ for any program, it should be set to +++<cite>+++/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK+++</cite>+++. On my machine this points to the 1.6 JDK: [source,bash] ---- $ ls -alh /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK -> /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents ---- This was a bit surprising to me since I've actually got Java 7 installed on the machine as well so I'd assumed the symlink would have been changed: [source,bash] ---- $ java -version java version "1.7.0_09" Java(TM) SE Runtime Environment (build 1.7.0_09-b05) Java HotSpot(TM) 64-Bit Server VM (build 23.5-b02, mixed mode) ---- https://twitter.com/andres_taylor[Andres] and I were looking at something around this yesterday and wanted to set +++<cite>+++$JAVA_HOME+++</cite>+++ to the location of the 1.7 JDK on the system if it had been installed. We eventually came across http://developer.apple.com/library/mac/#qa/qa1170/_index.html[the following article] which explains that you can use the +++<cite>+++/usr/libexec/java_home+++</cite>+++ command line tool to do this. For example, if we want to find where the 1.7 JDK is we could run the following: [source,bash] ---- $ /usr/libexec/java_home -v 1.7 /Library/Java/JavaVirtualMachines/jdk1.7.0_09.jdk/Contents/Home ---- And if we want 1.6 the following does the trick: [source,bash] ---- $ /usr/libexec/java_home -v 1.6 /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home ---- We can also list all the JVMs installed on the machine: [source,bash] ---- $ /usr/libexec/java_home -V Matching Java Virtual Machines (3): 1.7.0_09, x86_64: "Java SE 7" /Library/Java/JavaVirtualMachines/jdk1.7.0_09.jdk/Contents/Home 1.6.0_45-b06-451, x86_64: "Java SE 6" /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home 1.6.0_45-b06-451, i386: "Java SE 6" /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home /Library/Java/JavaVirtualMachines/jdk1.7.0_09.jdk/Contents/Home ---- I'm not sure how I've never come across this command before but it seems pretty neat.

java-findingsetting-jdkjava_home-on-mac-os-x

https://markhneedham.com/blog/2013/06/15/java-findingsetting-jdkjava_home-on-mac-os-x

2013-06-15 13:04:53

neo4j/cypher: Finding single hop paths

The neo4j docs have a few examples explaining how to to write http://docs.neo4j.org/chunked/snapshot/cypher-cookbook-path-tree.html#cookbook-return-partly-shared-path-ranges[cypher queries dealing with path ranges] but an interesting variation that I came across recently is where we want to find the individual hops in a path. I thought http://en.wikipedia.org/wiki/List_of_Chelsea_F.C._managers[the managers that Chelsea have had] since Roman Abramovich took over would serve as a useful data set to show how this works. So we create all the managers and a 'SUCCEEDED_BY' relationship between them as follows: [source,cypher] ---- CREATE (ranieri {name: "Claudio Ranieri"}) CREATE (mourinho {name: "Jose Mourinho"}) CREATE (grant {name: "Avram Grant"}) CREATE (scolari {name: "Luiz Felipe Scolari"}) CREATE (wilkins {name: "Ray Wilkins"}) CREATE (hiddink {name: "Guus Hiddink"}) CREATE (ancelotti {name: "Carlo Ancelotti"}) CREATE (villasBoas {name: "Andre Villas Boas"}) CREATE (diMatteo {name: "Roberto Di Matteo"}) CREATE (benitez {name: "Rafael Benitez"}) CREATE (ranieri)-[:SUCCEEDED_BY]->(mourinho) CREATE (mourinho)-[:SUCCEEDED_BY]->(grant) CREATE (grant)-[:SUCCEEDED_BY]->(scolari) CREATE (scolari)-[:SUCCEEDED_BY]->(wilkins) CREATE (wilkins)-[:SUCCEEDED_BY]->(hiddink) CREATE (hiddink)-[:SUCCEEDED_BY]->(ancelotti) CREATE (ancelotti)-[:SUCCEEDED_BY]->(villasBoas) CREATE (villasBoas)-[:SUCCEEDED_BY]->(diMatteo) CREATE (diMatteo)-[:SUCCEEDED_BY]->(benitez) CREATE (benitez)-[:SUCCEEDED_BY]->(mourinho) ---- We want to write a query which will return the 'SUCCEEDED_BY' pairs starting from Claudio Ranieri and working down. We might start out with this query which starts from Ranieri and goes all the way down the tree finding the next successor: [source,cypher] ---- START m = node:node_auto_index(name="Claudio Ranieri") MATCH path = (m)-[rel:SUCCEEDED_BY*]->(successor) RETURN EXTRACT(n IN NODES(path): n.name) ---- [source,text] ---- ==> +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> | EXTRACT(n IN NODES(path): n.name) | ==> +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> | ["Claudio Ranieri","Jose Mourinho"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink","Carlo Ancelotti"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink","Carlo Ancelotti","Andre Villas Boas"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink","Carlo Ancelotti","Andre Villas Boas","Roberto Di Matteo"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink","Carlo Ancelotti","Andre Villas Boas","Roberto Di Matteo","Rafael Benitez"] | ==> | ["Claudio Ranieri","Jose Mourinho","Avram Grant","Luiz Felipe Scolari","Ray Wilkins","Guus Hiddink","Carlo Ancelotti","Andre Villas Boas","Roberto Di Matteo","Rafael Benitez","Jose Mourinho"] | ==> +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ==> 10 rows ---- That gives us all the combinations but unfortunately it includes all the previous successors as well so it's not quite what we want. We need to manipulate the query such that we have a list of all the managers and can then follow a single 'SUCCEEDED_BY' relationship to find their successor. We could easily get that list of managers by following the 'SUCCEEDED_BY' relationship and getting the nodes on the other side but that would lead to Claudio Ranieri being excluded since he doesn't have an incoming relationship. To keep Ranieri we can make use of the 0 length path like so: [source,cypher] ---- START m = node:node_auto_index(name="Claudio Ranieri") MATCH path = (m)-[rel:SUCCEEDED_BY*0..]->(mm) RETURN mm ---- [source,text] ---- ==> +--------------------------------------+ ==> | mm | ==> +--------------------------------------+ ==> | Node[8]{name:"Claudio Ranieri"} | ==> | Node[9]{name:"Jose Mourinho"} | ==> | Node[10]{name:"Avram Grant"} | ==> | Node[11]{name:"Luiz Felipe Scolari"} | ==> | Node[12]{name:"Ray Wilkins"} | ==> | Node[13]{name:"Guus Hiddink"} | ==> | Node[14]{name:"Carlo Ancelotti"} | ==> | Node[15]{name:"Andre Villas Boas"} | ==> | Node[16]{name:"Roberto Di Matteo"} | ==> | Node[17]{name:"Rafael Benitez"} | ==> | Node[9]{name:"Jose Mourinho"} | ==> +--------------------------------------+ ==> 11 rows ---- If we now follow the 'SUCCEEDED_BY' relationship from our list of managers we end up with pairs of managers: [source,cypher] ---- START m = node:node_auto_index(name="Claudio Ranieri") MATCH path = (m)-[rel:SUCCEEDED_BY*0..]->(mm)-[:SUCCEEDED_BY]->(successor) RETURN DISTINCT mm.name, successor.name ---- [source,text] ---- ==> +-----------------------------------------------+ ==> | mm.name | successor.name | ==> +-----------------------------------------------+ ==> | "Claudio Ranieri" | "Jose Mourinho" | ==> | "Jose Mourinho" | "Avram Grant" | ==> | "Avram Grant" | "Luiz Felipe Scolari" | ==> | "Luiz Felipe Scolari" | "Ray Wilkins" | ==> | "Ray Wilkins" | "Guus Hiddink" | ==> | "Guus Hiddink" | "Carlo Ancelotti" | ==> | "Carlo Ancelotti" | "Andre Villas Boas" | ==> | "Andre Villas Boas" | "Roberto Di Matteo" | ==> | "Roberto Di Matteo" | "Rafael Benitez" | ==> | "Rafael Benitez" | "Jose Mourinho" | ==> +-----------------------------------------------+ ==> 10 rows ---- The code for this is available on the http://console.neo4j.org/?id=dzs5bn[neo4j console] if you're interested in playing with it further.

neo4jcypher-finding-single-hop-paths

https://markhneedham.com/blog/2013/06/15/neo4jcypher-finding-single-hop-paths

2013-06-15 09:53:15

neo4j/cypher/Lucene: Dealing with special characters

neo4j uses http://lucene.apache.org/core/[Lucene] to handle indexing of nodes and relationships in the graph but something that can be a bit confusing at first is how to handle special characters in Lucene queries. For example let's say we set up a database with the following data: [source,cypher] ---- CREATE ({name: "-one"}) CREATE ({name: "-two"}) CREATE ({name: "-three"}) CREATE ({name: "four"}) ---- And for whatever reason we only wanted to return the nodes that begin with a hyphen. A hyphen is a special character in Lucene so if we forget to escape it we'll end up with an impressive stack trace: [source,cypher] ---- START p = node:node_auto_index("name:-*") RETURN p; ---- [source,text] ---- ==> RuntimeException: org.apache.lucene.queryParser.ParseException: Cannot parse 'name:-*': Encountered " "-" "- "" at line 1, column 5. ==> Was expecting one of: ==> <BAREOPER> ... ==> "(" ... ==> "*" ... ==> <QUOTED> ... ==> <TERM> ... ==> <PREFIXTERM> ... ==> <WILDTERM> ... ==> "[" ... ==> "{" ... ==> <NUMBER> ... ==> ---- So we change our query to escape the hyphen: [source,cypher] ---- START p = node:node_auto_index("name:\-*") RETURN p; ---- which results in the following exception: [source,text] ---- ==> SyntaxException: invalid escape sequence ==> ==> Think we should have better error message here? Help us by sending this query to cypher@neo4j.org. ==> ==> Thank you, the Neo4j Team. ==> ==> "START p = node:node_auto_index("name:\-*") RETURN p" ==> ---- The problem is that the cypher parser also treats '\' as an escape character so we need to use two of them to make our query do what we want: [source,cypher] ---- START p = node:node_auto_index("name:\\-*") RETURN p; ---- [source,text] ---- ==> +------------------------+ ==> | p | ==> +------------------------+ ==> | Node[4]{name:"-one"} | ==> | Node[5]{name:"-two"} | ==> | Node[6]{name:"-three"} | ==> +------------------------+ ==> 3 rows ---- Alternatively, as https://twitter.com/cleishm[Chris] pointed out, we could make use of parameters in which case we don't need to worry about how the cypher parser handles escaping: [source,ruby] ---- require 'neography' neo = Neography::Rest.new query = "START p = node:node_auto_index({query}) RETURN p" result = neo.execute_query(query, { :query => 'name:\-*'}) p result["data"].map { |x| x[0]["data"] } ---- [source,text] ---- $ bundle exec ruby params.rb [{"name"=>"-one"}, {"name"=>"-two"}, {"name"=>"-three"}] ----

neo4jcypherlucene-dealing-with-special-characters

https://markhneedham.com/blog/2013/06/15/neo4jcypherlucene-dealing-with-special-characters

2013-06-13 22:18:31

git: Having a branch/tag with the same name (error: dst refspec matches more than one.)

git-having-a-branchtag-with-the-same-name-error-dst-refspec-matches-more-than-one

https://markhneedham.com/blog/2013/06/13/git-having-a-branchtag-with-the-same-name-error-dst-refspec-matches-more-than-one

2013-12-20 18:07:36

Supporting production code: Start with the simple things

A few months ago I wrote about http://www.markhneedham.com/blog/2013/07/22/lessons-from-supporting-production-code/[my experiences supporting production code] while working at http://www.uswitch.com/[uSwitch]. Since then I've been working on support for Neo4j customers and I've realised that there are a couple of other things to keep in mind while debugging production problems that I missed from the initial list. == Keep a clear head / Hold back your assumptions The first is that it's very helpful to completely *clear your head of any assumptions* when looking at a problem. I've got into the habit of pattern matching different error messages that I come across with root causes and while that's sometimes useful, often there are subtle differences which mean the root cause is different. Although I still sometimes fall into the assumptions trap I've found that it helps to ask exactly what someone is trying to do rather than immediately trying to solve the problem. == Look for the simple things Along with the assumptions another mistake I make is to imagine the most complicated version of events that could lead to a problem manifesting. Sometimes this is the case but more frequently a configuration setting may have been misunderstood or a query poorly designed and the problem can be resolved more easily. To stop myself making this mistake I have a rough flow chart in my head working down from simpler causes to more complicated ones for different problem areas. As I said, I still do make assumptions and look for complicated reasons for problems but by keeping these two things in mind I think/hope I'm doing it less often than I used to!

supporting-production-code-start-with-the-simple-things

https://markhneedham.com/blog/2013/12/20/supporting-production-code-start-with-the-simple-things