[ This post was originally published on Medium. ]
This is a short story of a couple of college kids who made a difference, who did something big because they loved and believed in whatever they were doing.
I’m a computer science student at Georgia Tech and I live thousands of miles away from my old friends and family. I’ve been to several college hackathons in the US like MHacks and HackMIT and I always dreamt of throwing one in my little country — Georgia. The fact, that I’m from the country of Georgia and now I live in the state of Georgia is often a source of confusion. But for now, whenever I say Georgia, I mean my beloved little country where I was born and I will make sure I’ll do everything to make a huge difference here, give people more opportunities to become successful and happy because Georgians are smart as hell, they just need a chance.
I believe that hackathons are changing the way we live and they give people invaluable opportunities where the only enemy you have is your own creativity (or lack of it).
It was a late November morning when I was talking to my friends in Google Hangout, when we first talked about hackathons in general. I shared my hackathon experience with them and they were angry they didn’t have the possibility to attend one. And there was a minute of silence. And we all shouted out loud: Let’s throw one in Georgia!
We were extremely excited and created the hackathon website right away with some basic info. We thought we needed to create a small group or organization (later we called it uniHack) that would unite us more formally and help us in negotiating with companies and future sponsors. All of us were from different schools and universities so we all tried to talk to some local Georgian colleges to give us some space and help us throw the first college hackathon in the history of Georgia — hack@CST. Finally, the deal was made and Caucasus School of Technology in Tbilisi, Georgia — gave us space and support although they didn’t really understand what we were really doing. And we started looking for sponsors and speakers for tech talks. We all had our responsibilities and discussed the progress we were making once in a couple of days.
We were desperate, because we had only one month till the start of the hackathon (December 20). We spent hours every single day talking to companies trying to explain what was the hackathon and why it was a big thing. We gave them the opportunity to become the part of the history, because I think we created a new Georgia with limitless epic ideas, extremely smart kids and bright future.
Finally, we managed to find couple of Georgian companies who got the real value of what we were doing.
I bought my ticket to Georgia. We had just one day before the hackathon to meet up and work on the details.
And then… December 20-21-22… Sleepless and the happiest hours we’ve ever had. Lots of new friends, smartest kids and hackers with the wierdest sense of humor, the most epic projects ever and one of the most interesting tech talks that I’ve ever listened to.
Only a few had heard of the word “hackathon” before hack@CST. No one but us, couple of kids believed that Georgia was ready for this. But I believe that it is never early to change something. It is never early to make a difference. It is never early to DO EPIC SHIT.
Don’t get me wrong. I’m not being emotional. At least I’m trying not to be. But those hours… those goddamn hours changed the way I look at things now. Now I truly believe that impossible is nothing. It’s all about being in love with your thing, no matter what it is. There are no borders, there is no limit, there’s nothing that can stop you. I believe that there’s nothing that can stop those Georgian college hackers who really blew my mind. And I want to let the world know:
Georgian kids DID EPIC SHIT, THEY FUC*ING DID IT!
P.S. I think you should also watch this: Calisthenics at hack@CST.
What’s up everybody?
I just started playing with Node.js and wanted to write something really simple but useful at the same time. At the end, I came up with an idea of writing sms translator, meaning that a user sends a text message to a given number and he/she gets the translated word within milliseconds. The app is very simple (just ~30 lines of code) and uses the following technologies/services:
1. You text the word you would like to be translated and two other strings: ”from” and “to”, the language from which and to what language you would like it to be translated.
e.g: your text might look like this: “girl en es“.
Keep in mind that your text should follow the above format (<word> <language_from> <language_to>) and the language codes should be of the following ISO format: List_of_ISO_639-3_codes
2. Twillio sends the message to your web app which is hosted on heroku.
3. Your app sends a request to glosbe.
4. Whenever your app gets response from glosbe, it sends it to Twilio, which then texts you the translated word.
1. set up you app on heroku. Follow this step-by-step guide.
2. set up Text Messaging with Twilio. After you register, you will get a free trial number. Then you should go to your Twilio Dashboard and change SMS Request URL to your web app’s link (link of your app on heroku).
That’s it! If you followed the steps had no problems setting up heroku and twilio, whenever you(or anyone else) send a text (<word> <lang_from> <lang_to>) to your twilio number, you will receive a a text containing the translated word.
P.S. Do not forget to put your Account SID and Auth Token (can be found on your twilio dashboard) in web.js (line # 4).
If you have any questions, you can comment below and I will try to answer!
Hey everybody! I was reading some blogs and a very good book – Lucene in Action these days and wanted to write this post for several reasons:
As a quick intro, Apache Lucene is a full-featured text search engine library written in Java (but now ported on many languages as well, including: C++, .NET, php, etc.). Lucene is an open source project maintained under the Apache umbrella and has a very active community. To give you a general idea about the importance of Lucene, you should know that it is used by the companies like LinkedIn, Twitter, Netflix, Hi5, IBM, etc.
Lucene is not:
Indexing is a process of converting text data into a format that facilitates rapid searching.
Components for Indexing:
Acquire content (not up to Lucene).In order to index something, obviously we need data – text. The source can be pdf, Word documents or just html retrieved by crawling. But it is essential to remember that we should parse it and convert it into plain text before we index the collection of files.[If you choose decide to crawl the websites Apache Nutch will help you and for extracting the text, maybe you should look at Apache Tika.]
Build Document. Once you have the raw content, you should build a document. Each document consists of fields such as “content”, “author”, “abstract”, “url” and so on. Field is a <key,value> pair, for example, if we are trying to index a blog article, one possible field can be “content” and its value can be the body of the article. In other words, documents contain fields and fields are what contain “real” data.
Analyze Document. During the indexing process, the text must be analyzed before it is stored into an index. Lucene provides a number of good analyzers itself but you can feel free to customize the existing one or build your own for your applications purposes. Analyzers convert the text into tokens, make them lowercase, do stemming and etc. In short, they prepare the text to get indexed.
Search UI. This is probably the most essential part of your application, because nobody cares about all the fancy algorithms you’re using under the hood, if they don’t feel comfortable while searching. Keep your search UI as simple as possible but provide most of the functionality of your application. As Edsger Diijkstra says, “Simplicity is prerequisite for reliability”. Keep in mind that Lucene doesn’t provide any kind of UI (as we already mentioned, it is just a library). So it’s entirely up to you how you implement it.
Build Query. OK, the user adores our search UI and decides to send his/her request to our application which is submitted to our server. We have to somehow translate this request into a search engine’s Query object so that we can tell our app to find our query in the index. Query objects can be simple and complex, depending on the user input. Say, user wrote just one word in the search box and clicked the submit button. In this case, the query object is pretty simple (Lucene will translate it as a TermQuery object). But the user input can also be a sentence or multiple sentences. For more complex queries, Lucene has several classes like PhraseQuery, BooleanQuery, FuzzyQuery and etc. The query is the parsed by QueryParser. For simple applications Lucene’s QueryParser is sufficient but you can add your own logic to it if you like.
Search Query. After we build the query, we try to retrieve results from the index that matches our query. Lucene provides several theoretical models of search: Pure Boolean Model, Vector Space Model. Since 4.0 version, Lucene provides experimental api for BM25 too. Lucene’s default approach is to combine vector space and boolean models. At the end, it returns the top scoring documents from the index.
Render Results. Once Lucene returns the top documents, we have to present them to the user in a consumable and elegant manner. Again, this is also up to your application logic how you present the search results to the user.
Hope it was interesting.. Stay in touch!