2680 éléments (416 non lus) dans 70 canaux
Actu
(37 non lus)
ZDNet News
(35 non lus)
Coulisses de Bruxelles, UE
Big Picture
neopodia
Le Caennais déchaîné
Eco
(11 non lus)
Tech
(109 non lus)
jy[B]log
Glazblog
DLFP - Dépêches
(6 non lus)
DLFP - Journaux
(3 non lus)
Android Developers Blog
Planet Libre
(49 non lus)
Blog Xebia France
(5 non lus)
OCTO talks !
(7 non lus)
Blogs
(49 non lus)
Journal d'un avocat
Standblog
(3 non lus)
C S P
CaZenCo - Commentaires
Le blog de Cyrille BORNE
Toutes les videos
articles
BD
(17 non lus)
Ma vie est une bande dessinée
Calvin and Hobbes (Unofficial)
(16 non lus)
Tu mourras moins bête
Melakarnets
BugBlog
A boire et à manger
Les webcomics
L'actu en patates
YODABLOG
.chez kek.
Cadavre & Cadavre
Drole
(191 non lus)
A bas les bébés !
En attendant que l'Euroland se dote, d'ici la fin 2012, d'un projet politique, économique et social commun de moyen et long termes, suite notamment à l'élection du nouveau président français François Hollande, anticipée depuis de nombreux mois par LEAP/E2020, les opérateurs resteront prisonniers des réflexes de court terme liés aux soubresauts politiques grecs, aux incertitudes sur la gouvernance de l'Euroland et aux risques sur les dettes publiques. [Lire la suite...]Je partage avec vous aujourd'hui la vision du "GlobalEurope Anticipation Bulletin", qui est pour moi de loin une des meilleures sources d'information sur la Crise. Toujours une tonalité très "europtimiste" - je pense pour am part qu'on va sacrément attendre les avancées sur le projet politique... Mais bon, il est indispensable en ces temps troublés de lire des visions très différentes pour s'aiguiser l'esprit...
Pascal Canfin est Eurodéputé Europe Écologie. C'est un des rares qui combat efficacement le financiarisme actuel. Il a largement milité pour la création de Finance Watch. Et il a été à l'origine, après de longs combats, de l’interdiction des ventes à nu de CDS souverains - ce pour quoi j'ai eu envie de l'interviewer. Je le remercie d'avoir répondu à toutes mes questions, en particulier les plus impertinentes... [Lire l'interview...]
Vous trouverez ci-joint un papier que j'ai rédigé, publié dans La Tribune (désormais hebdomadaire - soutenez ce journal ;) ) du 27 avril.
« La crise est finie, Ah crions le bien fort, Nous nageons dans l’bonheur » chantait déjà Albert Préjean en 1934 – la suite ne lui ayant malheureusement pas donné raison… Nous vivons actuellement une pause bienvenue dans les étapes de la crise – ou plutôt des crises – que nous traversons depuis cinq années, mais il est plus que probable que cela ne soit que l’œil du cyclone, et que les évènements reprennent prochainement leur marche funeste. Car le processus de désintégration financière n’a pas trouvé son aboutissement, et car aucune correction sérieuse n’a été apportée au système économique pour l’empêcher de dérailler de nouveau. [Lire la suite...]
Just a quick post so I can say I’m going to both events: Akademy 2012 and the Qt Contributors Summit 2012. I hope to see many of you there, and we have a lot to discuss and work on.
Tales from the Flight Log
Spring flight season is over, since it’s now over 9000 degrees farenheit in the great deserts of Arizona. We’re making a plan to head out to BALLS this year, but that’s not until September, and I won’t be launching then, so there is plenty of time to rebuild the Arcas and see what else we can put together on the Smoke.
Arcas HV Flight 1Certification flight, sponsored by Geoffrey Kerbel of SSS. Preparation on site with replacement rail guides and friction fitting of nosecone and body tubes. Launched with Geoffrey’s electronics.
Successful event at a guess of 3000 feet (4300 feet predicted by OpenRocket)
High level winds blew it to the east 0.75 miles for recovery. Recovered successfully with minimal damage:
Geoffrey deemed it safe to fly again, since the only damage was repairable on-site with 15 minute epoxy, NAR level 1 certification achieved.
Repair 1Summer rebuild.
Sanded and cleaned them up before re-attaching them.
Began some limited research in to converting the Smoke in to a dual deploy. * Rocket is too stubby for dual deploy to be completely feasible * Limited room for both drogue shoot and motor to justify needing a dual-deploy
Shopped for motors. It’s a 54mm mount, I currently own a 3-grain Cesaroni Pro38. As far as I can tell, as a result, our best choices are:
CTI 3-Grain 38mm MotorsThis is our cheapest option. We have a CTI 3-Grain Pro38, so we’d just need a 54-38mm motor mount adapter, which is like 15$ from whatsuphobbies.
They’re aren’t overtly exciting, about the same apogee as the Arcas achieved on the same motors. They’re about 40$ a pop, and that’s pretty reasonable to get this thing up in the air.
CTI 5-Grain 38mm MotorsThis is the border between Level 1 and Level 2 and aren’t much more expensive than the 3-Grain rockets. 5-Grain 38mm contains a lot of really interesting combinations, such as everyone’s favorite the CTI I540-WT and a few Level 2 rockets like the CTI J270-G.
That J270 is probably a good, cheap candidate for a Level 2 certification.
CTI 3-Grain 54mm MotorsThis will require me to get an NAR level 2 certification, since all 3-grain 54mm are either a J or K impulse. They’re also a lot more expensive. They also go three times higher than 3-Grain 38mm Motors. It’s also supersonic.
This post is part of an ongoing series about developments and discussions in Qt.
Some parts of this report are still under discussion, and don’t necessarily reflect the final state of Qt 5. The target audience is people involved in Qt development itself, but without the time to follow everything that happens, and others with a strong interest in Qt, Qt 5, and the community.
This week we cover some more of the QPA API changes and conventions, discussion of implementation of icon themes, packaging concerns, and exception handling. The number of interesting feature commits is still declining, which reflects the focus on bug fixing and stability towards Qt 5.0.
QPA API naming convention changedThe proposal to set a different naming convention for the Qt Platform Abstraction API, as previously discussed has landed in Qt. As the set of QPlatform* classes do not guarantee Binary compatibility, they should not be used in user applications, but only in platform plugins.
The platform abstraction API is in headers which are grouped in a qpa directory, so that it is necessary to use
#include "qpa/qplatformscreen.h"
for example. The user also needs to use QT += -private in qmake code to use the QPA APIs.
QScreen gets refreshRate APIThe QScreen class represents a screen in Qt 5. Recently its API was extended to notify about the refresh rate of a screen on particular platforms.
QScreen is part of the application developer facing QPA API. It provides read-only access to properties, and notifies the application developer when those change. The corresponding platform developer API is QPlatformScreen, which has the binary compatibility guarantees set out above (or lack thereof). QPlatformScreen has a virtual refreshRate method in this case which platform developers can reimplement to differ from the default 60 fps.
Homogenising Shared value class copying and movingA proposal from KDAB engineeer Marc Mutz to make copying and moving of some pimpl’d classes more consistent was submitted. This proposal adds swap() member methods to many classes to the copy-swap idiom easy and effective. Copy constructors can then be implemented in terms of a swap method, which in the case of pimpl’d classes means just swapping a pointer, so it is very fast and does not fail.
This could have performance benefits in Qt, but does not affect 3rd party code.
Icon theme implementationAn interesting thread brought up the issue of icon themes and in particular conformance to a FreeDesktop specification for naming conventions.
Qt 4 had some built-in handling for icon sets in KDE and GNOME environmentsl, but new QPA APIs in Qt 5 will allow giving more control to the platform plugin regarding how icons are loaded from a theme.
Optimizing Qt development on UbuntuA report from the Ubuntu Developer Summit brought up some feedback from packagers regarding Qt development. The issues regard seamless integration of the Qt SDK, avoiding conflicts between Qt 4 and Qt 5, and how the appropriate platform plugin should be loaded.
QtDeclarative compatibility module removedAnyone building the QtDeclarative module may have seen very long command lines with preprocessor defines between QtDeclarative class names and QtQuick class names. This was a temporary measure to raise the available source compatibility of other Qt modules depending on Qt declarative, but QtDeclarative was not a real module.
The module name situation has now settled down regarding declarative. The Qt 4 module ‘QtDeclarative’ is named ‘QtQuick1′ in Qt 5, and should not be used for new code. In Qt 5, the qtdeclarative repository contains two new libraries – QtQml and QtQuick. These two libraries were split from the Qt 4 QtDeclarative code, so they have the same API, but different class names. It seems like a confusing naming situation for people undergoing the transition, but the take-away is that in porting from Qt 4 to Qt 5 you should port from QtDeclarative to QtQml and QtQuick modules.
Exceptions in Qt 5The use and configuration of exceptions has been cleaned up somewhat in Qt 5. On some platforms, notably WinCE, they have been disabled at configuration time, which causes problems for QtXmlPatterns which itself uses exceptions. Several other Qt modules use exceptions such as QtConcurrent, and the rest should be as immune to exceptions in 3rd party code as possible. Qt does not generally provide strong exception safety guarantees, and does not handle them properly.
The solution is to disable exceptions wherever they are not explicitly needed and enable them only in modules where they are required.
Preparations towards Qt Contributor Summit 2012The planning around the upcoming Qt Contributor Summit in Berlin is ongoing. The summit is designed to be an unconference, allowing attendees to engage in many ad-hoc discussions, but a partial program has also been added to give some structure to the event, and to ensure that some topics get covered.
See you in Zaragoza tomorrow :-)
And of course, thanks to the sponsors! BlueSystems, Wadobo and Qt/Nokia, you rock!
About two weeks ago I went to Re:Publica, a hipster event (can I say that?) in Berlin. It was an interesting event - related to the stuff I usually visit, yet different. I'll go over the differences, then present what I see as the challenge for Free Software events: get those creative, digital and always-online people closer to us!
AudienceThe main audience of the event could probably be best described as people interested in the 'digital lifestyle'. People who use smartphones, are always on-line. They find their places-to-go on foursquare, talk to their friends on facebook, share their opinions on twitter, Whatsapp with their love - but they don't hang out on IRC or visit forums very often and they probably have a Macbook Air and a high-end android phone. Yes, not that different from us.
SubjectsThe event featured talks on things like the web, new cloud services like on-line music and creativity like music and video tools, open video etcetera. But that was only about 10-20%. Another 20-30% was about the future - social media, social innovation and more. To my surprise, the remaining 50% of the talks was about Freedom - and I use the capital for a reason. The Occupy movement, Digital Restrictions Management, Net Neutrality, Open Data, Digital influence on revolutions, eco-journalism, (internet) governance. Very close to what we, the Free Software community, hold dear (and find interesting!) Yes, not so different from us.
Marketing and artworkYou can imagine - an event organized by hipsters creative people looks good. It does! Team t-shirts were sponsored by spreadshirt and had the title 'actionist'. There was a big wall with the program, using pictures of the speakers, QR codes and more weird stuff. A twitter stream on a screen is old, people. Here, if you tweet a hash-tag you get your face as part of a logo shape or you get a gift if you check in with foursquare. That's more like it. Oh, and they had a 'carry your own chair' program - not unlike we did at the last openSUSE conference at the end of each day, except that it was 'cool', not 'please help us out with moving chairs'!
There were other things, too. Interesting or just plain weird stickers - with just a QR code or a shortened link, or only a slogan. There was stuff like a live steaming camera so you could interact with people on-line (easy to do: a laptop with a webcam connected to a google hangout?!?) and plenty of other good ideas. Surely different from what we usually do!
Challenge for us?I lately have been feeling that Free Software is loosing the battle for the hearts. Privacy and security are not important, internet is just a tool. We've been trying to educate people about Freedom but they don't care.
I was wrong. Collaboration and Freedom DO matter and people know it. We just don't reach the most of those who care about these things. This is where our challenge lies!
After talking with others and thinking about this, I conclude that there are two things we have to do better:
As distributions are slowly adopting our instant messaging suite, we get more and more questions from people everyday. And to give a proper support, we need a proper place to do so. So we decided to meet our users half-way and we created a special KDE Telepathy section at [forums.kde.org] - you can find it here, in the Internet & Network section. We're watching that forum and will try to help you, our users, as best as we can. So if you have any questions or want to discuss something, jump over there and ask away.
Big thanks to einar77 and the rest of our KDE sysadmin team for making this happen, as always - you guys rock!
Just read another "forget desktop Linux" piece by a writer trying to cover Free software on a sight ostensibly doing the same. This is exactly the sort of thing I wrote about in a recent blog entry, and it's sad to see it continue.
First off, "world domination" is not the only metric, nor the most useful one in every case. We have tens of millions of users around the world and I'm sure they'd appreciate it if we didn't forget them. I am one of them, and I know I certainly feel that way. You may be as well.
There's another aspect to that article: it suggests concentrating on mobile. Now .. where have I heard that before? Oh, right: everyone saying the desktop is dead, long live the web, we should focus all our efforts there.
Wake up call #1: hundreds of millions of laptop and desktop systems are sold each year. It's a market that isn't going away. Nothing is "killing" it. It is being displaced to some extent, but it isn't going away. It's less interesting because it isn't growing, and the corporate drive for ever increasing profits thus stamps it as "mature, boring." This is different from "dead."
Wake up call #2: there is no reason we can't do desktop and mobile and web. Yes, "and", not "or". Free software projects could create very compelling horizontal integration between these sectors as long as we treat them as not being mutually exclusive choices. This is part of the strategy of both Apple and Microsoft (and others), and the market would berate either for saying that they were abandoning some of these tech segments to focus exclusively on one. In KDE, our focus on the desktop has been extended to devices and the web in the last few years, and that's a good thing, something that should be supported. Which brings me to:
Wake up call #3: If people engaged in supporting Free software can't manage to keep long term focus, not freak out and continue to support the efforts that are ongoing ... we're screwed. We are, and will be, our own best friends or our own worst enemies. It starts by not telling others to stop supporting the efforts of thousands of volunteers and companies from around the world. That is, simply put, a betrayal.
A sophisticated view would be an examination of how we can draw together the efforts and successes of mobile for the desktop to give it a boost; to analyze how Free software desktop products and Free software mobile and web products can integrate and work well together.
There are projects and teams out there doing exactly that right now. Several teams in KDE are doing exactly that, and we mean business. It would be nice to not have to keep pulling knives out of our backs from journalists as we continue pushing forward. Long live Free software on the desktop, mobile, web and server!
Having experienced the MakerBot at work, I bought a EMaker Huxley last year. Once you get into the habit of being able to print any mechanical piece that you need (almost), you are forever hooked. Now, I’m looking to build a larger machine and am sourcing material for a building larger RepRap Mendel Prusa V2.
As the price for material is affected by both volume and the transport, I figured that a bit of joint purchasing would be nice. If you are based in western Sweden (i.e. can get to Gothenburg or Alingsås), or is willing to pay for the postage within Sweden, and you wants to join in, add a comment here or drop me a mail (e8johan, gmail). Being able to build bearings, nuts and bolts by the hundreds makes it feasible to source them from far away, e.g. China, or just to get a better price at the local stores.
If you tend to want to keep your music running when you log out, or control your music playing on a desktop machine from a laptop, for example, you may well use the Music Player Daemon (MPD). If you use Ubuntu’s Unity desktop or KDE’s Plasma desktop, you may well wonder how to get the Ubuntu sound menu or Plasma’s Now Playing widget to talk to it.
Both of these use MPRIS2 to communicate with media players. MPD, however, does not have an MPRIS2 interface. Even if it did, it would take a bit of work to be able to use it from another computer. What you need, then, is a “bridge” of some sort to translate. One such possibility is mpDris2 (which, I hasten to point out, I haven’t tested).
You would run such a bridge on the computer you want to control MPD from, and point it to your MPD instance. And voilà! Every MPRIS2 client application that you run can talk to MPD, without knowing anything about the MPD protocol.
If you just want a headless music player on your local machine, though, you can always use Raven, which talks MPRIS2 natively.
Come, buy and eat hotdogs and drink beer in support of LinuxTag!
In KDE3 times the “scheck” style from kdesdk/scheck could be used by developers and testers to “highlight accel and style guide conflicts”, like this (from the README):
).Just, the scheck style has never been completely ported to Qt4/KDE4! Since the begin of the KDE4 era it has stayed in kdesdk but excluded from any build. And now in the preparation of the migration of kdesdk module to git-based repositories any unported submodules will be moved to tags/unmaintained/4, already next sunday, May 20th.
So take a look at the current sources and consider giving it some Qt4/KDE4 love
If you are interested, please subscribe to the new mailinglist for kdesdk.
I spent some free time today getting caught up on the large backlog of phonon-gstreamer bugs. Towards the end, I started to have delusions of grandeur: Imagine a phonon-gstreamer codebase that doesn’t require supporting a zillion different audio frameworks, and instead belays that task to something that I don’t have to maintain.
My question here, is how many people would throw a fit if phonon-gstreamer dropped support for ALSA and OSS, and forced everyone to use pulseaudio by way of GStreamer’s excellent pulseaudio support?
Hold on, lower your pitchforks for a minute. Let us consider the audio framework landscape in the modern world:
Additionally, I really don’t feel like testing phonon-gstreamer on all those different kernel-level interfaces with exotic setups every time I fix a bug and am afraid I’d introduce another twelve. The PulseAudio folks seem to do a fantastic job at that already. Phonon isn’t meant for real-time playback or production studio quality audio. Thats what Jack is meant for.
I can’t think of a good reason why we shouldn’t stand on the shoulders of giants by making PulseAudio handle all the hard stuff on Unix involving massaging PCM formats, equalizers, matching playback category with output device, enumerating outputs both real and virtual, volume control, etc.
If you can, leave a comment on this post. I’m not making an official statement saying that I’m definitely removing ALSA and OSS support from phonon-gstreamer, I’m merely asking for feedback to see what can be done to fix things at all levels in the audio stack.
Sirko brought up the idea to organise a hackfest together with developers of applications for Linux desktops and experts interested in colour management. The idea behind that event was to bring interested developers together, support them in implementing color management in their software and move forward that topic across desktops and distributions.
During the recent LGM we found a chance to involve Richard Hughes and planed together about what we like to do during the hackfest. We spotted three main areas of interest: desktop applications including window managers, web browsers and printing. These topics are already worked on, but in a scattered way.
As example, Gwenview is a really great application for managing pictures. But it has no color management implemented yet. Color management in KWin is worked on during the GSoC this year, but in the opposite color management in the compositing manager mutter on the GNOME side is far away as can be read here. Not many web browsers support color management and if they who do, it is often incomplete. The SVG v2 standard will for example introduce additional color management features compared to SVG v1. So it is now the right time to get these implemented in order to be well prepared. For the KDE printing stack there is also a GSoC project this year, but also the Linux Foundation has a working group for this topic.
So, by meeting in person in one place, we want to get something done and build a good understanding of the role of each participating group for a working end to end colour management.
The hackfest will very likely happen in Brno in the Czech Republic at the Red Hat offices. A good time appears later this year 16th till 19th November. Now we like to collect more ideas, speak to people and sort financial issues.
Continuing with my previous post about the Zeitgeist team’s improvements with regards to speed, there’s a nifty tool in the sources I wrote yesterday that uses a genetic algorithm to find the slowest queries you can throw at the engine.
If you’re not familiar with genetic algorithms, here’s a brief review of how they work:
In the case of this Zeitgeist tool, the chromosome refers to a query, and each allele (index of the array) refers to an attribute of the query. Here’s a relevant comment from the sources:
# Chromosome to data mapping: # 0, 1 - Timerange begin and end. If both are zero, we use timerange.always() # 2 - The search type. Anything over 30 is a dead individual. # 3-5 - Specify template properties. Anything besides 0 and 1 is dead. # 3 - Specify a subject interpretation # 4 - Specify a subject manifestation # 5 - Specify an event actor
Using the super cool pyevolve library, implementing a genetic algorithm is super easy:
def eval_func(chromosome):
query = buildQuery(chromosome)
if query is None:
return 0
start = time.time()
results = engine.find_events(*query)
overall = (time.time() - start)
return (results["find_events"]*2+results["find_event_ids"]*4+results["get_events"])*1000
genome = G1DList.G1DList(6)
genome.evaluator.set(eval_func)
ga = GSimpleGA.GSimpleGA(genome)
ga.evolve(freq_stats = 1)
query = buildQuery(ga.bestIndividual())
assert query is not None
print query, len(engine.find_events(*query))
Let it run for a long while on a big database, and you end up with a query that takes forever. Due to how evolution works, it isn’t the longest running query, but it is certainly one that takes a long time.
Hey everyone, I am riding 100 miles (161 km) for Chicago’s 2012 Tour de Cure. My goal this year is to raise $1,500, because last year I was blown out of the water by the generosity of the people at my mom’s work, the KDE community, the cycling community, and a few friends. So, if 300 of you donated the minimum $5, I would make my goal 
Last year I had a blast doing this ride and completed it in 6.5 hours. My other goal this year is to finish it in under 6 hours.
To donate, you can click on the Support image above, or go to my Tour de Cure page. Scroll down, and on the right hand side you will see “CLICK HERE TO SPONSOR ME”, click it. I appreciate any and all help!
Donate To My Tour de Cure 2012 Ride is a post from Richard A. Johnson's blog.
We are pleased to announce the new open-slx Weekly News 18 in the Formats PDF and EPUB.
You can find in this week (abstract):
The open-slx Weekly News 18 are downloadable there [881,31 kB] (PDF) and there [11,94 kB] (EPUB).
Because Textwriters are needing Coffe just donate anything.
Original Post: [community.open-slx.com]
Technorati Tags:Technology, News, Mobile App, Tablet, Tablets
Download: PDF-Format [881,31 kB] EPUB-Format [11,94 kB]
Dieser Wochenrückblick wurde unter der Creative Commons by Share Alike veröffentlicht.
Wir freuen uns, den neuen open-slx Wochenrückblick 18 in den beiden beliebten Formaten PDF und EPUB zu veröffentlichen.
Unter anderem in dieser Woche:
Der open-slx Wochenrückblick 18 kann hier [833,53 kB] (PDF) und hier [19,10 kB] (EPUB) heruntergeladen werden.
Da Textschreiber immer wieder einen Koffeinschub brauchen, kannst du hier einen Kaffe spenden.
Original Post: http://community.open-slx.com/news-41-open-slx-wochenrueckblick-18-veroeffentlicht.html
Ältere Ausgaben können hier eingesehen werden.
Technorati Tags:Technology, News, Mobile App, Tablet, Tablets
Download: PDF-Format [833,53 kB] EPUB-Format [19,10 kB]
Dieser Wochenrückblick wurde unter der Creative Commons by Share Alike veröffentlicht.
Europes biggest event arround Linux and Open Source – LinuxTag, is’nt far away anymore and Oyranos will participate on it. LinuxTag take its place in Berlin from 23.-26. May on the exhibition area arround the Funkturm. On saturday the 26th of May I will present together with Sirko an talk about colour management – “Bring Color To The Game“. The talk will not introduce Oyranos as CMS, it will more explain what color management is and about the actual status on free desktops. We want as well to talk about what a user needs to get colour management running. During LinuxTag I will be reachable on the openSUSE booth for questions and introduction into profiling and bring some colorimeters.
As mentioned in my previous post, you can now link your documents, files and folders to your activities. That, by itself, isn’t much. The first thing that you could do with that is show the linked documents on your desktop by using the Contour layout, which is quite nice even outside of Plasma Active, but although usable on the desktop as well, it has some problems.
So, how to make this available to the normal users, you ask? Easy – make it available to the normal file managers via KIO – just type activities:/ in Dolphin, Konqueror or the Folder View applet, and you’ll get a list of all activities, and files that belong to them.
You can see what it looks like in the screenshots. At the moment, it is a bit buggy, but it will work as expected for SC 4.9.
Hi all,
I am sri13 @ IRC. Last year, I completed GSOC under KDE and did some work in Krita. Now, I am not doing any thing in krita and I am feeling very bored as there are no challenging tasks. . 
Any new challegenes to do in KDE or Krita . . ?
Please tell me . . ,I wanna try different . . 
A picture of Oz Fox from Stryper I took ages ago. We’re rock stars.
So, after working on the cool “Large image displaying library” in KHTML I decided to look into other parts of KHTML, and work on getting my lolcat page working in KJS/KHTML. It turned out quite easy, KHTML is very friendly, both the code base and the community around it.
So, after fixing a couple of other small issues, I decided to take on Twitter which has stopped rendering properly in KHTML/KJS. Thanks to the excellent debugging support in the khtml kpart, it only took a couple of minutes to track the error down. The issue turned out to be that the maximum stack size in the KJS interpreter was too small, Twitter is serious about its Javascript. The issue is then if we should bump up the maximum amount of stack frames, since if we eat up all the available stack space we can get nasty crashes without Dr. Konqi (the crash reporting tool) showing up. But for now KHTML in git should render Twitter just fine.
Lastly, a tip if you want to debug production sites with long lines in KJS; turn on the “Reindent Sources” option if it is slow, the katepart embedded in the javascript debugger isn’t a fan of the long lines most websites put together.
And as usual, thanks to the KHTML developers for help with everything.
Having got the first release of LightDM out the way we're looking forward to what our future releases should entail.
0.1 was released purely so we could start testing and get feedback as to what features need to be added for subsequent releases. In some areas we are already ahead of KDM, and even the LightDM frontend used by Unity but in some areas 0.1 is really lagging behind and there's a lot to be done before it's "complete" and ready for distributions to ship.
What's coming in 0.2 Multi-screen supportI have a branch which hopefully makes some progress on this. However with only one screen this is somewhat hard to test! Ideally I need to work with upstream to come up with a QML plugin that we can use in KSplash-QML too.
Live previews in the config toolOne of the special features of LightDM-KDE is that it's really easy your settings, such as change your wallpaper or add a company logo. I'm adding a way to show a live preview of this whilst you change the settings.
KSplash has a QML backend, we're powered by QML...by copying the same code from our greeter theme to a KSplash theme it will look identical. This means we can load the same background you chose for your login screen, and we won't have the issues with differing aspect ratios that we see in KDM.
General improvements0.1 shipped with several bugs, broken translations, poor keyboard shortcuts, and loads of UI bugs. We're slowly fixing these, including getting a lot of these changes merged upstream back into Plasma Components. Massive thanks to Aurélien Gateau for his help on this.
PowermanagentThis has already been implemented thanks to Alex Fiestas.
How to try out in Kubuntu 12.04Even though LightDM isn't the default display manager in Kubuntu it made it's way into the repositories, installation and testing is one command away. You will then be prompted as to wether you want KDM or LightDM to be your default display manager. You don't need to change the default just to try it.
Can I see a screenshot that isn't related to anything you just said?sudo apt-get install lightdm-kde-greeter
Sure! Blogs without screenshots are dull, and it's hard to screenshot power management....
Report bugs to https://bugs.kde.org/ selecting the product lightdm. If you want to get involved coding or designing;,drop me an email (which can be found at the top of any header file of the source)! Or join #kde-lightdm on Freenode.
As Trever blogged yesterday, the Zeigeist team has been busy with tweaking the DB and the engine. During that process tools and benchmarks have been developed to make the tweaking and testing more interesting. Trever will be blogging about that tomorrow so make sure to check his blog.
Our end goal is trying to scale the engine to be able to handle a few billion events just as fast as it can handle a few hundred thousand. While we are not there yet we managed to have some pretty nice stable results for the first iteration. A lot of results show more than 100% speed enhancement. In other words a lot of queries from our standard benchmarks now consume more than 50% less time to execute. Here are some graphs of our benchmarks.
Green indicates the 0.9 release
Yellow indicates the new trunk
Most notable performance enhancement is querying Zeitgeist with a specified timeframe (from data x to date y).
Same queries with an open timeframe also improved
We also have a copy of the Synapse queries benchmarked
The queries here are typical queries used to extract info from Zeitgeist. So right now the team is really happy with the initial results. For Synapse on my local DB (over a year old), all my synapse queries perform under 0.08 seconds. We still can get more out of this. The trick here was improving our indexes and our sql query generator.
Next month we will be going through another iteration.
A repeated problem we run into when using QMake is that it focuses on being a build tool, and because of that does not implement some features for executing parts of the project (like tests). Others ran into this issue as well, as for example this discussion of specifying run configurations from QMake on Qt DevNet indicates. Multi-part projects often consist of dynamic libraries that contain the features, and applications and tests that link this library. Amongst other things, this approach allows tests to link objects which contain the application’s code. Now when the tests are executed, the dynamic linker needs to be able to pick up the freshly built library and link the test with it at execution time. Projects usually run test cases with make test, and ideally the tests should execute out of the box after the sources have been configured and built (out of the box meaning that no tweaking of the environment variables should be needed between make and make test). After all, it should be as easy as possible for developers to execute tests.
This is also a problem in IDEs like Qt Creator, but also others – for every build configuration (having separate shadow build directories), the developer needs to configure the library path before being able to debug the application. This second problem needs to be fixed in the IDEs. For the first one – configuring test runs from the QMake .pro file – we have developed a solution called QMakeTestRunner that takes care of the problem. QMakeTestRunner assists in setting library paths when running unit tests in products built with QMake. It makes make test work out of the box right after makefiles have been generated. It is Free Software, published on Github, and small and easy to integrate into projects as a Git submodule. Much of this information will go into the documentation on Github as well.
Motivation, aka “The Problem”QMake as a build system is simple and complete for building code, but it lacks a simple way to run unit tests dependent on libraries which are part of the project itself. In this case, paths which are created in the build directory need to be added to the dynamic linker library path before the tests can be executed. Especially with shadow builds, this would require manual setup, and make test would not work out of the box after QMake has been run.
QMakeTestRunner, aka “The Solution”As soon as any target in a QMake project has the testcase attribute assigned to CONFIG, QMake automatically generates a target called check that runs this test. Unfortunately, make check does not allow the manipulation of the linker paths before running the tests either. QMakeTestRunner contains boilerplate code that wraps QMake’s make check target with a new one called make test, and through variables specified in the QMake file allows the specification of paths to be added to the linker path.
UsageQMakeTestRunner is intended to be used as a git submodule to the main project. It should not require any modifications to be used. It requires Python to be in the path, checks for it, and the QMake run will fail if Python cannot be detected. When using other version control systems than Git, QMakeTestRunner should be small enough to simply be copied into the project as a subdirectory.
Project configuration exampleThe following example adds the directory libs/ in the project build directory to the linker path. It assumes the QMakeTestRunner repo is located under 3rdparty/QMakeTestRunner. The path where the dynamic library is generated in below the output (build) directory, which is why it is prefixed with OUT_PWD:
TEST_LIB_PATHS += $$OUT_PWD/libs include( 3rdparty/QMakeTestRunner/testtarget.pri )
To trigger extra diagnostic output of the test runner, add
TEST_VERBOSE = 1
before including testtarget.pri.
make testOnce testtarget.pri has been included, a test target is defined in the makefiles. Simply run make test to execute the original make check with the necessary paths.
Mac OSX FrameworksFrameworks on OSX are a different kind of library. The framework path is passed into the dynamic linker using a different environment variable. To specify a framework path, set the TEST_FRAMEWORK_PATHS variable before including testtarget.pri.
TEST_FRAMEWORK_PATHS += $$OUT_PWD/frameworksSetting up QMakeTestRunner as a Git submodule
Using a Git submodule has the benefit that the code for the runner does not need to be duplicated into the repository of the project that is supposed to use it. It also makes it easy to pull updates to the test runner by simply updating the submodule to a new revision. To add the submodule as 3rdparty/QMakeTestRunner in your project, follow these steps:
> mkdir -p 3rdparty > git submodule add git://github.com/AgileWorkersSoftware/QMakeTestRunner.git 3rdparty/QMakeTestRunner > git submodule init
The directory 3rdparty/QMakeTestRunner should now contain the current revision of the test runner scripts.
License, contributions, issues and supportQMakeTestRunner is Free Software licensed under the GPL, version 3. Contributions to it are welcome, please propose them as Github pull requests. To submit a bug report or feature wish, please use the Github issue tracker for the project.
Commercial support for QMaketestRunner or general issues with QMake is provided by Agile Workers Software. We are happy to help.
I just came up with a trick question. Let’s see if you can solve it.
Why will 20 become smaller when you add another zero?
Update: Commenters have been very creative. My original solution was to add the zero at the front, yielding “020″, which is 16 in many programming languages. Other solutions are “20^0 = 1″ include “0.20″.
The Zeitgeist team has been hard at work lately. We recently moved from Launchpad and Bzr to freedesktop.org and git, just in time for the 0.9 release. Since then, Seif and I have been hammering away at making a bunch of speed improvements and trying to scale the engine to be able to handle a few billion events just as fast as it can handle a few hundred thousand.
Our first experiment has been focusing on the sqlite indexes. This one index tweak appears to increase our benchmark speeds by almost 45%:
CREATE INDEX event_timestamp_subj_interp_subj_id_id
ON event(timestamp, subj_interpretation, subj_id, id)
And here’s the graph to prove it:
Shorter lines are better. Blue is the 0.9 release, and the orange is the tiny index change. All of our raw data is in this google spreadsheet, so feel free to have a look. I can’t guarantee that you’ll immediately understand the information, but I’m open to explain it to those interested.
With Krita 2.4 happily released, the Krita team is working hard on what will become Krita 2.5. Krita 2.5 should be released some time in July already, but that doesn't mean that it will be a boring release! Here's a short overview to whet your appetite:
WindowsKrita on Windows is getting more and more stable. The installer you can download from the KO GmbH download page still warns you that it is extremely experimental, and that's true! I regularly build it from git master, and as any artist can confirm who uses Kubuntiac's script, that's dangerous living. But on the other hand, at first we got many reports from people who couldn't run Krita for one reason or another, and we seem to have fixed most of those problems. And then -- Oscar Baechler used a beta of Krita on Windows for his workshop at LinuxFest Northwest with few problems.
SmudgingLast week, we got a new smudging option for the colorsmudge brush: dulling. This works a bit like smudging in Mypaint currently works. In git master, we already have a few presets that use this mode! Check Animtim's blog for more information -- this screenshot is from his blog.
David Revoy also quickly produced a very painterly sketch:
The compositions docker allows you to save sets of layer configurations. So, if you have a complex layer structure, you might want to hide or show sets layers and switch between those configurations, say your sketch structure and your paint structure. Sven's blog has all the details! And David Revoy made a video showing why it's a really handy feature:
{youtube}Ngov6Xh8Zew{/youtube}
Paper sizesWe used to have a set of old templates for the various color models Krita supports in various sizes. This actually isn't what the templates were intended for, so we added a selection box to the custom image window that allows you to select predefined size/dpi combinations. The templates section is thinned out a bit and need filling up again. See the how-to-create-a-template tutorial on the forum.
Textured paintingAs requested by David Revoy, Krita now allows you to use a texture to modify your brush while painting. The feature isn't finished yet, but will be ready for 2.5.
ThemingOn Linux (on Windows there are some technical problems that we hope to be able to solve), you can now select a color theme for just Krita. We borrowed code from Digikam for that -- thanks Gilles et al! No longer do you need to make your entire desktop dark to have a dark look for Krita. As seen in the screenshot above.
Improved OpenRaster supportOpenRaster got extended thanks to the efforts from MyPaint's Andrew Chadwick, and Krita has followed suit: OpenRaster (and .kra) now saves and loads the lock status of layers as well as which layer was active.
Preview in Pattern SelectorThe pattern selector got a large-size preview pane and was also turned into a docker.
And there'll be lots and lots more to look forward to!
Kdenlive 0.9 has just been released. We encourage all users to upgrade to this new version that fixes many small issues and should improve the overall user experience. Some of the new features include:
The effect stack was rewritten to allow adjusting parameters for several effects in one go. Effects can also be grouped, groups can be saved and effects or groups can be dragged and dropped onto another clip
Automatic audio alignmentIf you have been working on a scene with several camcorders, Kdenlive can now automatically align the clips in timeline using the audio.
Easy import of online resourcesKdenlive now has an online resource browser that allows you to easily preview and import audio, graphic and video resources from archive.org, freesound audio library and open clip art.
Usability improvementsMany small improvements and bugfixes should make your use of Kdenlive nicer and smoother, for examples:
The Kdenlive 0.9 source tarball can be downloaded from the KDE servers: download link.
Binary packages will be announced in our download page
A big thank you to all the people that contributed in one way or another to improve this new version. Some bugfix 0.9.x releases will be made when necessary, but in the background we are working (well mostly Till) on a refactoring to cleanup the code and hope to reach the 1.0 milestone by the end of the year, thanks to the fantastic success of our fundraising campaign.
As usual, users are welcome to join our forums and bugtracker to report problems.
This post is an update about the research project from my team, described a few weeks ago.
From the time we published the last post about QML Styling until now we have worked on this set of issues/features:
Last week, we have read a few blog posts, and talked with a few Qt & KDE application developers about what should be the priorities for creating desktop and mobile applications. I have presented our proposed solution for using native look and feel for QML widgets, how to create custom styles from scratch, using the CustomStyles helper, and how to apply them with the ApplicationStyle API.
Based on the feedback and the blog posts, my team sat down and came with the following set of statements which summarize our vision for what sould be our focus of our current research:
We decided to choose the ComboBox component to work on because it is one of the most complex (if it isn't the most). Because of the complexity, we hoped that during its development we could be enlightened of knowing if we are in a correct path, what still misses, and what should be the next steps.
As we did in the Slider approach, which was divided in 3 different subcomponents:
While creating the ComboBox, we decided to divide it in 4 other subcomponents:
We basically mimicked how QStyle splits the QComboBox painting into subcontrols. The drop list was also delegated a sub style as QComboBox does with it's internal QListView. We haven't worked on the drop list style since it would require a native style such as Plasma's ListItemView, which also would rely on a ScrollBar.
Creating the combo box component showed us that positioning and size hints can be more tricky than it looks like.
The ComboBox got stuck in a few parts and unfortunately it's not complete right now. However we took the questions and answers from its development. :-/
Positioning and Size HintsThis topic of discussion came out when we were thinking about a theoretical style in which the ComboBox would be in the left. One of the issues we had in mind while developing the editable ComboBox was how to set a MouseArea that can know when set the focus to the text edit or to open the drop list. This would be possible to be done with current QStyle, since on it's approach the QWidget reads the subcomponent's size hints by the subControlRect method from QStyle.
We would like to have this positioning information on the style as well. The approach can be similar to what happens with the size, which you can read it from the widget reference.
The following piece of code is a simple example of how size hints can be taken:
// ComboBox.qml
Item {
property alias arrowStyle: arrowControl.sourceComponent
Loader {
id: arrowControl
width: arrowControl.implicitWidth
height: arrowControl.implicitHeight
}
MouseArea {
anchors.fill: arrowControl
onClicked: {
// do some action
// ...
}
}
}
ArrowStyle defines the implicit size, which works as a size hint, and the position where they are. These properties together can work analogue to subControlRect, as they hold the same info. The component may ignore such hints and override the properties values, such as Slider's Handle style position.
// MyComboBoxArrowStyle.qml
Image {
implicitWidth: 50
implicitHeight: comboBox.height
x: comboBox.width - width // Arrow could also appear on the left by setting x = 0
source: "arrow.png"
}
One may ask "Can't I have a round button with a circular hit area?" That's more complex than just setting hints for the geometry of sub control styles. As we defined in our view we're trying to be at least as powerful as QStyle. We consider that, by now, we should be strict at least about the interaction styling of the components themselves. From my point behaviour difference should be defined as the component API.
Sub StyleComponents SetsAnother discussed topic was about the fragmentation of the style property of the components. For instance, take the following Slider style code:
// Slider style now
Slider {
grooveStyle: CustomGrooveStyle { ... }
handleStyle: CustomHandleStyle { ... }
}
The Slider style property is fragmented as more than one property. We thought that these properties could be centralized with a SliderStyle as an aggregator object. This helps API clarity for style manipulation since we can play with a single object reference that represents the component style, enabling to handle it atomically.
// Proposed Slider style usage
Slider {
sliderStyle: CustomSliderStyle { ... }
}
with CustomSliderStyle as:
// Proposed Slider style creation
// CustomSliderStyle.qml
// Aggregated style object
SliderStyle {
grooveStyle: CustomGrooveStyle { ... }
handleStyle: CustomHandleStyle { ... }
tickmarksStyle: CustomTickmarksStyle { ... }
}
or more compactly:
Slider {
sliderStyle: SliderStyle {
grooveStyle: NativeGrooveStyle { ... }
handleStyle: CustomHandleStyle { ... }
}
}
or even:
Slider {
sliderStyle {
grooveStyle: NativeGrooveStyle { ... }
handleStyle: CustomHandleStyle { ... }
}
}
This issue is only an idea only discussed between ourselves. It would be nice to have feedback about these API.
Insights from SceneGraph & QStyle studyThe isolated study of the scene graph internals (getting rid of QQuickPaintedItem), and how it could be used to create the new styles directly on it, didn't told us much in fact. Only that is better we keep doing these styles in QML and using Scene Graph itself to create sub elements that needs a more refined handling.
On the other hand, the Windows and Mac styles investigation was very important to decide our next steps. It showed us that these styles uses platform native APIs to draw the native widgets on each platform on pixmaps. So we would have to deeply study these API to create our own implementation of native styles using the scene graph. For these reasons isn't too simple to give up from QQuickPaintedItem some time to going deep on them right now since our time and head count is limited.
Two steps forward, one step backAfter the feedback from other developers, one of the main thing people want more is to have a widget set working with the native look and feel as soon as possible. Keeping this as our primary focus, we will left the restriction of depending on QtWidgets for now. So we will focus on having a working solution that can be easily replaced after. Fortunately, our proposed modular solution for styling fills that requisite.
Just a couple weeks ago we launched the renewed download.kde.org. The layout I had chosen was dated before it was implemented it seemed. I was pleasantly surprised that a couple days after I announced it, the webteam had the first mock-ups ready for a new theme. This general theme is called Neverland, and has been rolled out slowly on a few sites already.
I think the webteam deserves some more credit for their work, so I’m going to highlight some of the remarkable things they pulled of the last months. The first ‘challenge’ they had was to give the new bugzilla a new layout. The new bugzilla was rushed from the sysadmin side, this was caused by a serious security issue we found. Hence the webteam only had a week to come up with some layout. And they did. Unfortunately a week was too little time, and at the launch the new layout was not so good. Then the team had to operate for a few weeks with a smaller team, but when the team was back on full strength, bugs.kde.org was fixed and it now rocks. I’m very proud at it.
Another project the webteam took on was to apply Neverland to forum.kde.org. The forum is a big site, with a lot of users. Unfortunately the forum is very underestimated by developers. It really is a fun place to hang around. Some developers now start to discover the forum and are very excited about it. It’s a great place to communicate in a pleasant way with actual users of your application. Much better than via bugs.kde.org in my opinion. If you want a forum for your application, just let the team know. Anyhow, they rolled out the new theme there too, which was a big chunk of work. If you want a *very* cool impression of the changes and about the possibilities of Neverland, just look at their Tour!
And more recently they applied the new Neverland theme to download.kde.org. Instead of a boring index of all files and folders, it now has a nice background, nice fonts and a nice expandable header with the contents of the .message file in each folder, all in line with the rest of the Neverland-sites.
So a big thanks to the webteam. Especially Sayak Banerjee, Eugene Trounev and Ingo Malchow!
As we slowly move more and more software from svn to git, we need an extra anonymous git server. If you are a company providing virtual machines and love to do something for a big open source community, this is your chance!
We are looking for a virtual machine which we can use and which will be dedicated to provide an anonymous git service to our community. We had a couple of such servers until recently, but we had to say goodbye to one, because the SVN-size of our repo is also still growing, and that server did not have enough disk space to do both. Another one had some load issues, so we had to make a choice to take that one out of rotation too. We still have 2 left, but one malfunctioned today. And then suddenly we were left with only 1.
Hence this call for a new server. The specs are not that high, just some disk space (50GB would be nice), root access, somewhat good processors and a good internet connection.
We do have a small preference for a company this time, people offering a part of their private server is always appreciated, but for an anongit server, we would like good uptimes, quick response when there are problems, etc. Other wishes we have involve a KDE pastebin for images, some enhancements to files.kde.org and some more, so if we get more than one offer, I hope we can use the servers for those wishes.
In return you get list at our famous Thank You-page. We can even put your logo on there if the offer is very generous :) If you are interested mail us at sysadmin@kde.org.
This is coming about two weeks later than I would have liked, so the next pre-release is likely to come in two weeks to make up. Similarly, the monthly bugfix release for Muon Suite 1.3 is two weeks late. For that, I’ll likely just skip this month and release 1.3.2 in two weeks, as there haven’t been any serious bugs that need immediate attention. (Thankfully)
Anyways, I am proud to announce the first alpha release for Muon Suite 1.4. The Muon Suite is a set of package management utilities for Debian-based Linux distributions built on KDE technologies. Packages for Kubuntu 12.04 “Precise Pangolin” are available in the QApt Experimental PPA. Here’s what’s new:
Muon Discover
Muon Discover is the experimental new frontend in the Muon Suite. It was written by Aleix Pol Gonzalez as part of his employment at Blue Systems, and it’s pretty nifty. You can read more about it here.The idea is to create a Muon frontend that makes finding new software super-simple, and doing so with a little bit of flair. It’s no secret, that even though the existing Muon Software Center has some “bling” here and there, the interface is somewhat spartan.
Muon Discover will eventually replace the Muon Software Center, but not just yet. Muon Discover is young, and its interface is written entirely in QML. KDE has not issued a set of comprehensive UI guidelines for QML usage on the desktop, and currently Muon Discover is using the Plasma QML components for several of the controls in its interface. While we wait for a set of guidelines, the classic Muon Software Center will remain the default application installer, allowing Muon Discover to mature in the process. The QML Desktop Components (slated for release sometime around Qt 5.1 or 5.2, or so I have heard rumored) and KDE Frameworks 5 will likely be a big part of KDE’s QML standardization, so expect Muon Discover to replace the Muon Software Center in around that time period.
Muon Software CenterWith all the buzz around Muon Discover, you may think that nothing has been done with the Muon Software Center. Well, never fear, as there are several cool new features and user experience improvements that have been made for Muon Suite 1.4.
The Muon Package Manager has not been forgotten, either. Highlights for the 1.4 release mainly include tools for better handling Multi-Arch packages on 64-bit systems.
Detailed changelogs for LibQApt and Muon can be found here and here, respectively.
I've been with SUSE now for almost 2 years now and it's been quite a ride. SUSE itself, however, has been having fun long before I joined. Heck, even before Free Software was on my radar (that's somewhere around 2000), SUSE was already going strong! November it'll be 20 years. Cool to see that in that time, Linux went from 'nothing' to "two-thirds of the global Fortune 100 uses SUSE Linux Enterprise"!!!
Join us?Talking about careers, I know the SUSE Studio team is looking for an UI designer. If you've played with SUSE Studio you know you've got some big shoes to fill. But it is an amazingly cool project with an amazingly cool team and an amazingly cool project lead - that would be Cornelius Schumacher, or Mister President for you!
The Technikum Wien provided a nice place and great support for the LibreGraphicsMeeting. Many thanks to them. LGM happened together with the Linuxwochen Wien and developers and users could talk about graphics and arts themes. Additionally to the one presentation track over all days, we had BoF’s and workshops. Some of us took the chance to present to a non LGM audience and meet people there too.
The LGM talks covered lots of OpenCL projects. That means modern GPU computing power is available to open source graphics components in a much broader way. As the use of OpenCL is supported by the Mesa software implementation, there is some kind of guarantee, that OpenCL programs will run on elder hardware. That means OpenCL can be used without the need for developers to provide a fallback mechanism, which simplifies adoption.
The colour management talks provided lively discussions around many topics like printing, displaying and open hardware. We discussed as well the impact of introducing colour management in frameworks like GEGL. As mizmo showed interest, I explained the most basic terms of ICC rendering intents in a small BoF using ICC Examin. Animtim compiled and installed Oyranos from sources and wrote already a small tutorial on how to build Oyranos on kubuntu-12.04.
Markus Raab presenting Elektra on LGM 2012 Vienna
The presentation of Markus Raab about the Elektra configuration gave to me some impressive insights into the concepts and flexibility of that small framework. The really cool thing about this library is it can abstract a lot of details and provide additional features, which can be added on run time like DBus support. He announced a new release of Elektra as version 0.8.0 during the event.
The metalab was for most people from countries without a similar open hardware/open source collaboration zone a impressive visit. We all enjoyed to could stay there for some hours and felt, this place is much in the spirit of most LGM contributors.
Nathan Willis @ LGM 2012 Vienna
During Nathan Willis workshop about the Create wiki, we discussed to start a email list for create users. That list is supposed to provide help and talk about experiences with graphics applications and help from users for users.
Sirko (alias gnokii) and Tobias (alias houz) played diplomat and managed to channel information in a way that Richard Hughes and I could finally meet in a productive atmosphere and continued talking about technical issues. At the end we found a mod to work again together on standards inside the OpenICC collaboration project. I am pretty happy with that change. So, thanks to all parties who helped with that.
Café Hawelka Vienna
Tatica, Pete, Sirko and I walked around on the last day in Vienna and relaxed in the café above.
I'm pleased to announce the new available EBook-Manager calibre package 0.8.51 for openSUSE.
Whats happend since the last Minorupdate? New FeaturesWhere to get Calibre?
You just can add the Documentation:Tools Repository and install it via YaST or zypper. You also can use one of the following 1-Click Installer:
This one for the openSUSE 12.1 Documentation:Tools (12.1 Standard)
This one for the openSUSE 12.1 Documentation:Tools (12.1 KDE 4.8)
It can take some time, because of the packages are build but at not available in the Repo. Should come next time.
You wish to donate anything to the Packager?Sounds good. Just read Donate a Coffee.
Have a look there (German Article). If you don't know german, just add the Documentation:Tools Repository and install "calibre-faenza-icons".
Hi, this is my first post on the planet. I am Martin Küttler, a mathematics student from Germany. I am very late with this, but still: I was accepted for GSoC this year! I proposed to implement a new interface for Cantor, and I am looking forward to spend the summer on this task.
Cantor's current interface (henceforth known as 'the old interface' :) ) uses a KRichTextWidget, which brings several limitations. Some of these could be worked around with some efforts (and some have been), but that's not a real solution, as KRichTextWidget just is not suitable for the worksheet interface Cantor strives for. That's why I want to implement a new interface based on the Qt Graphics View Framework. When it's done it is supposed to provide a better user experience without all the quirks (and occasional crashes) of the old interface, and with decent search and undo/redo features. On top of that it should bring a lot of new possibilities for user interaction, that are not (easily) possible with a mere text-based approach. In the end of the summer I intend to implement an inline input assistant for a convenient matrix creation.
The code can be found at the gsoc2012 branch of Cantor. It is working already, but a lot of the old features are still missing, and there are new features bugs instead. I intend to address those issues in the next few weeks, and I will post here when there are major improvements. But the code can be tried out already, and if you do so please leave a comment to tell me what you think of it.
It looks like this is going to be an exciting summer for Cantor, as Filipe Saraiva also started implementing a Python backend for Cantor. I'm really looking forward to it!
Our next release is scheduled in less than a month and because we want this release to really rock (and be stable as rock too), we're giving this whole weekend to fixing bugs. So far I've managed to fix all reported crashes in contact list and fix few other bugs and mem leaks. The Text UI component is getting some nice fixes as well. And I'm going to fix some annoyances in our kded-module, which will improve the integration of Telepathy in KDE Plasma Workspace.
We can still use some hands as our bug list is rather long and the day has only so many hours. If you'd like to help test or even fix bugs, head down to #kde-telepathy on freenode right now and we'll get you started. We have bugs ranging through the whole difficulty scale, so even if you are a beginner coder, we have tasks for you. Great opportunity to join the KDE development ;)
Also if you are using KDE Telepathy and you have some annoyances that you would like to see fixed, come tell us now in our irc channel and we'll give these bugs a special priority ;)
We're on untill Sunday night, so don't worry if you can't make it today :)
See you there!
Since quite some time, Kate Part has build-in scripting support through JavaScript. Our plan is to make this API public, so other applications like Kile, Kate App and KDevelop can use it. However, we are currently unsure how to best implement it, so this is a rfc to get feedback.
The bindings for a Kate Document are for instance located in part/script/katescriptdocument.h (header, implementation). As you can see, there are functions like
Q_INVOKABLE bool insertLine(int line, const QString &s),
which can be invoked in our scripting by a call of ‘document.insertLine(5, “hello world”)’. The API only contains basic functions. But for instance Kile maybe also wants to provide a function called ‘document.insertSection()’ or similar LaTeX related functions. The question now is as follows: How can Kile extend our QObject based prototype with their own QObject based classes?
We do not want to make the class KateScriptDocument public. Instead, we just want to return a QScriptValue containing a QObject based KateScriptDocument. You can think of the problem also as follows:
// in Kile:
QScriptEngine *engine = ...;
KTextEditor::Document *kteDocument = ...;
QObject* kateScriptDocument = kteDocument->scriptDocument();
engine->globalObject().setProperty("document", engine->newQObject(kateScriptDocument));
// at this point, the JavaScript object 'document' contains all KateScriptDocument functions
// next, we want to add the Kile related document functions
KileTextDocument* kileDocument = ...;
QObject* kileScriptDocument = kileDocument->...(); // some function that returns the binginds object
// now: how can we populate the 'document' property with the functions in kileScriptDocument?
engine->globalObject().setProperty("document", ? );
If you have any idea or other solutions how to do it right, please let us know!
Here is a little tutorial to help you install the powerful Oyranos Color-Management-System on Kubuntu 12.04
(at least on a KDE/Plasma desktop, as the Kolor-manager simple interface is on the KDE systemsettings panel, I’m not sure how to use it on other desktops).
So first thing to do is to add the getdeb repository to your system, as the latest Oyranos core is available from there.
- download the GetDeb repository installer , then double-click on it and install.
-in a terminal, run:
sudo apt-get update
sudo apt-get install build-essential git oyranos liboyranos-dev oyranos-icc oyranos-doc kdelibs5-dev xcalib libyajl-dev
Now that oyranos core is installed, you’ll want to use kolor-manager, which is a simple interface to setup oyranos easily.
Unfortunately, it’s not packaged yet on get-deb, so you’ll have to build it.
You’ll have to download the sources on a folder called, for example, sources/ ,
then create a build folder in it to make the build,
then install in another separate folder, called for example kdetest.
All this in your home, so it’s not mixed with system packages.
So to do all this, in the terminal:
mkdir sources
cd sources
git clone git://anongit.kde.org/kolor-manager.git
cd kolor-manager
mkdir build
cd build/
cmake .. -DCMAKE_INSTALL_PREFIX=home/USERNAME/kdetest
make
make install
Then in .profile (hidden file in your home folder, if it doesn’t exist already create one), add this line:
export KDEDIRS=$KDEDIRS:/home/USERNAME/kdetest
In case if you need several of these paths (like here I’ve another one for calligra/krita), separate them with : like this:
export KDEDIRS=$KDEDIRS:/home/USERNAME/kde4/inst:/home/USERNAME/kdetest
(of course replace USERNAME with your session name)
Now Restart your session, and you’ll can find the color management in the systemsettings panel 
Then in the parameters, you can define default profiles for all kinds of colorspaces.
I leave you the fun to discover all the features inside… Enjoy!
(Note: Like always when you build software, it depends on libraries installed on your system. I’ve tried to list all those needed in the apt-get install line, but I may have missed some as I already built several other softwares here… So if you have an issue at some point, feel free to send me an email using the contact form, with the output of the terminal pasted in it, so I can identify any missing libraries or other issues and fix this tutorial.)
(Note2: If you only want the Oyranos packages and no other update from get-deb, you can disable the repository after installing it so it doesn’t bring unwanted updates next time you’ll update your system. This is easy to do using Muon or Synaptic package managers for example…)
Pour la troisème année consécutive, les hackeurs du Tetalab et les artistes de Mixart-Myrys unissent leurs talents pour vous présenter ce délicat mélange de technologies et de spectacles qui feront le bonheur des petits et des grands.
Tout ceci se passe au sein du Toulouse Hacker Space Factory.
Cet évènement grandiose se déroulera du vendredi 25 au dimanche 27 mai à Toulouse dans le surprenant hangartistique de la culture alternative situé au 12 rue Ferdinand Lassalle (près des Ponts Jumeaux). Ouverture des portes à 18 heures pour 72 heures presque non-stop d'activités destinées à tout le monde, et même aux non-geeks et leurs enfants. Vous pourrez par exemple apprendre à souder vous même votre zombadge.
Tous les détails sont dans la seconde partie de la dépếche
Le programme complet donne les détails pour les diverses conférences, mais aussi les performances live, les ateliers disponibles, et pour les nombreux concerts, sans compter les gens qui vont venir hacker le festival des hackers par des actions surprises ;-) À noter que la totalité des festivités du week-end est en entrée libre, mais qu'il sera demandé une « participation libre et nécessaire » permettant d'augmenter l'indépendance du lieu.
Que vous soyez jeunes parents ou vieux loup, plus intéressés par une conférence ou bien par une mise en pratique en atelier, hardcore hacker, joueur de pacman, ou bien festif jusqu'à pas d'heure : ce week-end est pour vous, dans ce lieu galactique de rencontres et partages des cultures et savoirs-faire qu'est Mixart-Myrys.
Et une jolie nimage qui indique qu'il y aura des possibilité de restauration sur place. Pour le repas d'ouverture, vendredi à 20h, une réservation par mail est demandée : reservation@mixart-myrys.org . Une autre jolie nimage d'un atelier, et une dernière pour la root.
La core team Maarch est fière de vous annoncer la publication de la version 1.3 de Maarch Entreprise (licence GPL 3).
Maarch Entreprise est un Système d’Archivage Électronique (SAE) perfectionné, auquel sont ajoutées des fonctionnalités de Gestion Électronique de Documents (GED) et de Gestion Électronique de Courriers (GEC). Maarch Entreprise est un outil de production unique, entièrement open source et distribué sous licence libre.
La version 1.3 de Maarch Entreprise est une petite révolution car elle s'agrémente de fonctionnalités de gestion de contenu tous formats ! Et va toujours plus loin dans sa capacité à vous proposer des fonctionnalités de GED et de GEC performantes.
Pour découvrir toutes les nouveautés et installer cette nouvelle version, inscrivez vous à notre Install Party prévue le 15 juin 2012 dans nos locaux à Nanterre.
Écrite en PHP 5, Maarch Entreprise est une application web optimisée pour la circulation et la conservation de documents dans un environnement certifiable NF Z 42-013, ISO 14721 (OAIS) et MoReq2.
Les nouveautés de la version 1.3 Module de gestion de contenu (Content Manager)Le module de gestion de contenu ajoute une dimension ECM à notre solution SAE.
Le module de notification est amélioré afin de prévenir les utilisateurs de tout type d’évènement survenu dans l’application, par courriel ou flux RSS.
Maarch Entreprise 1.3 est accessible depuis smartphone et tablette, et permet l’ajout de notes sur les documents.
L’objectif étant d’utiliser la recherche avancée pour effectuer des recherches dans les corbeilles de chaque utilisateur, et trouver ainsi de façon plus simple un courrier au sein de ses corbeilles. Il permet également une action directe depuis le résultat de la recherche.
Les utilisateurs peuvent choisir à l’enregistrement / versement du document le statut de celui-ci et ainsi envoyer directement le document dans la corbeille correspondante. En version 1.2 et précédentes, un seul statut était possible au versement : NEW. À partir de la version 1.3, le statut des documents peut être « À Valider », « Clos »…
Amélioration des fonctionnalités courriersMaarch Entreprise 1.2 en quelques chiffres sur 1 an d'existence c'était :
+ 10.000 téléchargements dans 160 pays ! (statistiques sourceforge.net)
Nous sommes en milieu de mois et ceux qui ne sont pas encore passés par leur marchand de journaux ce mois-ci peuvent actuellement trouver en kiosque :
Et toujours trouvable en kiosque pour les retardataires, GNU/Linux Pratique Essentiel n°25, MISC hors-série n°5 sur le cryptographie et Planète Linux n°69.
NdM : la revue de presse est ouverte et collaborative. Si vous voulez parler de votre magazine préféré, ou prendre en charge un magazine spécifique, n'hésitez à nous rejoindre sur l'espace de rédaction de LinuxFr.org . Nous pourrons même vous faire gagner un abonnement au magazine choisi !
GNU/Linux Magazine n° 149 titre sur Btrfs, le système de fichier destiné à remplacer ext3/ext4. Vous ferez un tour très pratique des fonctionnalités de ce FS qui met à niveau les FS classiques des distributions Linux : modification de la taille, compression à la volée, mise en place de RAID 0, 1 10, les snapshots (reposants sur les sous-volumes), le tout agrémenté des lignes de commande qui vont bien. Le plus long article reste cependant issu d'Open Silicium avec la mise en œuvre par le menu d'une caméra IP à moins de 40€. Vous apprendrez la bidouillabilité pour pas cher et un peu de temps si le sujet vous intéresse.
Toujours côté embarqué et/ou temps réel, vous découvrirez Migen, un framework Python pour maniper et générer des circuits logiques et Nife, un langage proche du Forth pour l'embarqué et l'application pratique de la transformée de Fourier pour faire du traitement de signal sur ARM. Sinon, ce numéro passe en revue les nouveautés du noyau 3.3, vous propose le guide d'installation de Gnome 2 et Java sur OpenBSD pour y développer dans ce langage, le déploiement de SNORT et Base pour la détection et l'analyse des détections d'intrusion. Pour finir, côté astuce, un proxy local pour gouverner tous les autres proxy !
Que les développeurs se rassurent, GNU/Linux Magazine hors-série n°60 pense à eux, ils n'ont pas été oubliés. Enfin, principalement les javaïstes avec un smartphone tournant sous Android, mais bientôt, les amateurs de Blackberry ou encore Tizen grâce ầ OpenMobile. Ces Cookbooks sur Android (successions de how-to) sont très pratiques pour monter en compétence rapidement sur des problématiques classiques ou un peu moins. Les articles, classés à mon avis par ordre de difficulté, sont organisés sous forme de repas, cookbook oblige :
GNU/Linux Pratique n°71, toujours aussi éclectique, aborde tout un tas de sujets, mais l'audio (et le multimédia) sont un peu plus à l'honneur avec Ampache pour faire votre propre logiciel de streaming audio à la Deezer/Spotify, Audacity et sa dernière version et surtout la découverte très détaillée (avec mise en œuvre incluse) de Popcorn Hour, lecteur multimédia très complet. Parmi les autres sujets, l'installation de Subversion pour faire du LaTeX, la gestion de projets en ligne avec Feng Office, XWiki pour vos bases de connaissances, MODX comme système de gestion de contenu ou encore BSD comme OS au quotidien avec la version PC-BSD pour remplacer (avantageusement ?) une Ubuntu par exemple. Du côté des apprentissages et tutoriels, vous découvrirez comment fonctionnent les transactions sécurisées sur Internet (et comment créer votre propre certificat), la mise en place d'un serveur DHCP et d'un cache local de paquets logiciels. Et enfin, si d'aventure vous avez encore des réticences à contribuer à des logiciels libre, un dernier article battra en brèche les (faux) problèmes que cela pose.
Le dossier MISC n°61 s'intéresse à la sécurité des bases de données. Même si ce n'est qu'un pan de la sécurité d'un SI en général, c'est un très vaste sujet que MISC aborde via cinq articles touchant à différentes solutions :
Les autres articles en marge de ce dossier sont nombreux et abordent des thématiques variées. Parmi ceux-ci, j'ai noté l'« exploit corner » qui aborde une vulnérabilité Android permettant de passer root, le « pentest corner » qui montre, suite à des retours d'expériences d'audits de code que la sensibilisation des développeurs est indispensable, vous découvrirez qu'il est possible de mettre à mal la fameuse « plausible deniability » mise en avant par TrueCrypt et l'utilisation astucieuse des clés shellbags de Windows pour faire de l'analyse Forensique. Je vous laisse découvrir le sommaire détaillé.
Lilypond est un logiciel destiné à produire des partitions musicales de qualité optimale. Il vient de remporter le premier prix de l'un des concours les plus prestigieux pour les logiciels libres musicaux. Il s'agit du concours international LOMUS 2012 (LOMUS comme LOgiciel MUSical) organisé chaque année par l'AFIM.
LilyPond est un logiciel de gravure musicale, destiné à produire des partitions de qualité optimale. Ce projet apporte à l’édition musicale informatisée l’esthétique typographique de la gravure traditionnelle. LilyPond est un logiciel libre rattaché au projet GNU.
L’AFIM est l’Association Française d’Informatique Musicale. Elle a pour but le développement de l’informatique musicale en France, de ses relations avec les autres disciplines artistiques et scientifiques, de ses liens internationaux. Elle pilote notamment l’organisation de Journées d’Informatique Musicale JIM et participe au comité de pilotage de Sound & Music Computing SMC.
NdM. : le second prix a été attribué à Pyo (un module Python de traitement de signal numérique sous licence GPLv3).
Je viens de finir un petit projet en Go la semaine dernière, un assembleur vers du MIPS simplifié. Voici un petit retour d'expérience, en espérant que ça serve !
NdM : merci à G.bleu pour son journal.
Pour mes études, j'ai un projet (le dernier avant la vie active !) de réalisation de microprocesseur MIPS « from scratch ».
Le CPU est designé sous Xilinx ISE (grosso modo un IDE dans lequel on peut réaliser des designs de composants à base de portes logiques). Par la suite, il sera chargé sur un FPGA, celui-ci connecté à un robot afin de lui faire suivre une ligne sur le sol.
De fait, une fois le CPU designé, il faut réaliser un programme en assembleur MIPS, puis le convertir en binaire afin de l'intégrer dans le design du CPU sous la forme d'un module en VHDL. En gros, en entrée du module arrive l'adresse du program counter et le module sort l'instruction correspondante.
Les plus attentifs auront déjà pointé du doigt le souci : comment convertir proprement le code assembleur MIPS en binaire ?
À la main, ne riez pas, c'est ce que m'a proposé mon prof quand je lui ai posé la question ! À sa décharge, les élèves suivant ce cours ne sont pas informaticiens mais plutôt orientés électronique.
Utiliser un assembleur déjà existant. La solution « ne pas réinventer la roue » de référence. Le problème : l'output sera en binaire (logique, me direz-vous) mais je veux du code binaire lisible ! (en gros mon output doit être 000101011100110 afin de pouvoir directement copier coller le code dans le fichier de mon module VHDL). Ajouter à cela que je ne veux pas de header ELF ou quoi que ce soit, juste la transcription du code que j'ai écrit. Je pense, bien-sûr, qu'il y a des solutions pour arriver à ce que je veux. Néanmoins, j'ai du temps en ce moment et apprendre un nouveau langage me semble plus formateur qu'apprendre les options d'un outil qui ne me servira plus par la suite !
Écrire un assembleur à la main. La solution que j'ai choisie, et qui me donne donc la possibilité de réaliser ce journal ! Un assembleur n'est pas aussi complexe qu'un compilateur (et de loin !), mais permet déjà de s'amuser sur un nouveau langage.
Linus Torvald :
Show me the code !
Céans mon bon monsieur ! En espérant que tout le monde aime SourceForge…
Comme dit plus haut, il s'agit d'un assembleur MIPS « simplifié » :
Toute les instructions ne sont pas disponibles (pas de jump ou de subi par exemple). La raison est tout simplement que mon processeur ne prend pas en charge ces instructions et que je préfère avoir une erreur à la compilation si j'oublie ce détail que de devoir débugger une erreur qui n'en est pas une par la suite… Malgré tout, il est très simple d'ajouter ces fonctionnalités comme nous allons le voir.
Pas de header ELF pour le programme. Comme j'ai dit, l'idée est de copier la sortie de l'assembleur dans un fichier pour que mon cpu l'utilise "tel quel". Pas d'OS, pas de logique supérieure, rien ! Donc, pas besoin d'header.
J'ai divisé mon assembleur en 3 parties :
Il convient avant tout de parler un peu de la philosophie de Go avant d'aller plus loin.
En effet, l'idée est de fournir des outils tout prêts à l'utilisateur. On se base sur un maximum de règles standards et donc un minimum de configuration (voire en fait pas de configuration du tout dans bien des cas !).
L'exemple le plus frappant de ce concept est le makefile. Si dans les versions antérieures à la 1.0, Go possédait un simili makefile (il était déjà beaucoup plus simple qu'un makefile typique pour du C), tout cela est révolu !
Maintenant un projet Go n'a besoin pour compiler que de ses sources. Un coup de "go build" et tout se fait tout seul. Plus de gestion des dépendances, plus de problèmes de conflits d'includes (de toute façon, il n'y a pas d'include en Go)… voilà qui devrait intéresser, je pense, tous ceux qui se sont essayés à C++ et à ses célèbres erreurs de compilation hyper-verbeuses, pour cause de conflit de define pour avoir placé un include au mauvais endroit.
Petite remarque tout de même : Mon projet contient un makefile !
Bien que minimaliste, celui-ci est donc toujours présent.
La raison est multiple :
La commande "go build" construit votre binaire… et c'est tout ! J'aime pouvoir automatiser la génération de tarball, le nettoyage du projet, etc.
Mon projet utilise yacc (donc conversion du fichier parser.y en parser.go). De fait, go build ne met pas à jours parser.go si parser.y est mis à jour. D'où la nécessité de gérer cette dépendance
De la même manière, réaliser des tests est simplissime. Pour écrire des tests pour le fichier foo.go, vous n'avez qu'à créer le fichier foo_test.go et… c'est tout ! Ce fichier se fera automatiquement compiler et ses fonctions commençant par Test seront exécutées à chaque lancement de "go test".
Dans le fichier, on importe le package "testing", et on appelle la méthode testing.T.Fail() ou testing.T.Error("C'est la dèche !") pour signaler que le test a échoué :
import "testing"
func TestFoo(t *testing.T) { // Les fonctions de test commencent par Test
// et respectent cette signature
if test_is_ok() != nil {
t.Error("t'es parti pour fixer ton code !") // Erreur avec message
}
if test_sans_message != nil {
t.Fail() // Erreur sans message
}
// Si aucun appel à Fail ou Error, alors le test est considéré comme réussit
}
Le multiplatforme !
Encore une très bonne nouvelle : Go est multiplatforme de base !
Voulant partager mon logiciel avec mes petits camarades (Je précise que je suis en Corée du Sud actuellement… pas la peine de dire quel OS utilise tout ce joli monde !), autant dire que cette fonctionnalité a fortement pesé dans la balance pour le choix de Go.
En outre, selon la doc il est possible de cross-compiler à partir de n'importe quelle platforme pour n'importe quelle autre juste en changeant ses variables locales comme GOOS ou GOARCH (et bien-sûr en compilant sa chaîne de compilation pour l'architecture cible). Toutefois, je n'ai pas testé cette possibilité, j'ai préféré rebooter sous windows (à ma décharge, j'aurais de toute façon dû le faire pour vérifier que mon binaire fonctionne bien !)
J'ai toutefois trouvé un peu bizarre que la gestion du retour à la ligne ne soit pas fournie comme en C++ (avec std::endl). De fait, on doit faire attention à ce léger détail et différencier les cas selon les OS à la main, ce qui est assez dommage.
Les outils en plusEn bonus, go fourni des outils des plus sympa :
go fmt
Cette commande permet de mettre à LA norme le code. Notez le "LA" majuscule, il n'y en a qu'une (certains diront qu'elle est horrible mais nous ne sommes pas vendredi, je laisse cela à d'autres). Du coup, pas de conflits à ce niveau, tous les codes go écrits pas tous les développeurs du monde auront la même forme.
Petit bémol pour ma part : cette norme utilise des indentations de 8 caractères et ne coupe pas le code à 80 colonnes. Résultat, celui-ci est bien souvent trop long à mon goût (ainsi qu'à celui de mon Emacs en multicolonnes. Là où je peux mettre 3 colonnes en C la plupart du temps, je suis limité à 2 en go… 33% d'espace perdu, snif !)
go tool yacc
La commande go tool permet d'accéder à la foultitude d'outils intégré dans la commande go. Parmi eux se trouve yacc, le célèbre parser. Cette version est une réécriture en go de celui de plan9. Autant dire que sa présence à été déterminante dans mon choix d'utiliser go pour mon projet (un parser à la main… non merci !)
Après tout ce temps à parler des outils, parlons du code, du vrai !
Le retour de plusieurs variablesEn voilà une bonne idée ! Toute fonction peut renvoyer plusieurs variables au lieu d'une seule dans la plupart des langages.
De fait, on retrouve dans la lib standard de Go un bon nombre de fonctions renvoyant à la fois la valeur qu'on leur demande ainsi qu'un type "*Error" pouvant être soit "nil" (c'est-à-dire pointer sur rien) soit initialisé, signifiant alors une erreur. Plus besoin de "tricher" - comme en C - en donnant en argument de la fonction un pointeur sur la variable à compléter, puisque la variable de retour est déjà occupée par le code d'erreur.
De même, le parcours de tableau s'en trouve simplifié :
for i,elm := range array {
fmt.Println("l'élément", i, "a pour valeur", elm)
}
range est un mot clé permettant de parcourir un tableau en renvoyant, à chaque itération, la position ainsi que l'élément courant.
Notez aussi le ":=" permettant de déclarer "à l'arrache" des variable en fonction du type de la variable qu'on lui assigne. Un vrai bonheur pour gagner en lisibilité dans les cas triviaux.
Encore une bonne nouvelle ! La gestion des passages d'options étant une fonctionnalité essentielle à 90% des logiciels, le package "flag" s'occupe de cela avec brio !
import "flag"
var f_input = flag.String("i", "", "Input file.")
var f_output = flag.String("o", "", "Output file. (stdout if nothing specified)")
var f_type = flag.String("t", "vhdl", "Type of output : binary, print, vhdl")
func main() {
flag.Parse()
fmt.Println("lecture du fichier", *f_input)
...
}
Ai-je vraiment besoin d'expliciter ? On déclare les flags en dehors des fonctions, on appel flag.Parse() avant d'utiliser les flags (notez qu'il s'agit de pointeurs, on met donc une "*" pour les déréférencer)
Remarquez que l'option --help/-h est gérée automatiquement !
Go possède de manière intégrée au langage les conteneurs les plus utilisés :
MapSon nom est suffisamment explicite : une clé, une valeur.
Problème, selon moi : si la clé ne correspond à aucune valeur, la valeur nulle est renvoyée. De fait, dans mon programme, j'utilise une map pour faire la correspondance entre les labels et leur adresse réelle. Si je demande l'adresse d'un label inexistant, la map va me renvoyer la valeur 0, puisque c'est l'équivalent de la valeur nulle pour un int…
Problème : cette valeur peu tout à fait être valide dans le cas d'un label situé en début de code ! C'est d'autant plus étrange que le langage autorise le renvoi de plusieurs valeurs, comme nous l'avons vu précédemment…
Un joli tableau unidimensionnel de taille constante… rien à redire.
SliceUn type fourre-tout : c'est un genre de tableau à taille variable.
En réalité, le slice - comme son nom l'indique - représente un morceau de Array. De fait, plusieurs slices peuvent pointer en même temps sur le même Array, par exemple.
Je cherchais à utiliser un vecteur pour stocker chacune de mes instructions une fois parsées/lexées. J'ai eu la surprise de voir que le conteneur Vecteur avait été supprimé de la bibliothèque standard il y a quelques commits…
La réponse s'est trouvée sur la mailling list de Go : utiliser des slices !
Voici comment faire :
var s0 := []int{0, 1} // on créé un un slice sur un tableau contenant 0 et 1
var to_insert = 42
S0 = append(s, to_insert) // on utilise la fonction buildtin "append"
Simple ? Bon maintenant, voyons comment supprimer l'élément numéro i (en C++ j'aurais fait "vect.remove(i)")
s0 = append(s[:i - 1], s[i + 1:]...)
Pas glop ! Je pense qu'un peu de sucre syntaxique n'aurait pas été de trop pour cacher cette complexité inutile !
Pour ceux qui se posent la question, append ajoute des éléments à un slice. De fait, on doit transformer le slice s[i + 1:] en une suite d'élément avant de l'ajouter à s[:i - 1]. C'est ce qu'on fait avec la commande "s[i + 1:]…"
Dans Go l'héritage dans la grande tradition OO n'existe pas ! (et ce n'est pas pour me déplaire à titre personnel).
Le tout s'articule autour de trois concepts (que je n'illustrerai pas avec mon programme puisse que celui-ci n'en n'utilise pas le premier.)
Plutôt que de déclarer des classes, on crée des structures. Celles-ci pouvant gérer l'héritage d'une façon amusante :
type plat struct {
name string
}
type choucroute struct {
plat
saucisses int
}
func main() {
ch := choucroute{plat{"choucroute"}, 4}
fmt.Println("Je vais me tapper une", ch.name, "avec ", ch.saucisses, "saucisses dedans !")
// ces deux lignes sont rigoureusement identiques
fmt.Println(ch.name)
fmt.Println(ch.plat.name)
}
On remarque donc que, en ajoutant dans choucroute une structure plat de manière anonyme (le nom "_" l'équivalent en Go de John Doe…), les éléments de plat sont intégrés dans choucroute !
Les méthodesUne fois notre jolie structure déclarée, il est possible de lui adjoindre des méthodes :
func (ch Choucroute)manger() {
ch.saucisses--
fmt.Println("Miam ! Encore", ch.saucisses, "saucisses !")
}
func (_ Plat)manger() { // remarquez le "_" pour indiquer qu'on ne fera rien avec l'objet et qu'il n'est donc pas nécessaire de le nommer.
fmt.Println("Beark !")
}
Les interfaces
En Go, tout se base sur du Duck typing. De fait, afin de pouvoir manger à la fois un plat de seconde zone ou de la délicieuse choucroute, on peut déclarer une interface qui contiendra la fonction manger :
type mangerer interface {
manger()
}
func main() {
bouffe := []mangerer
bouffe = append(bouffe, choucroute{ "choucroute", 4 })
bouffe = append(bouffe, plat{ "bouts de tétons de mme Félipé" })
for _, pl := range bouffe {
pl.manger()
}
}
De fait, le duck typing faisant son travail, notre slice peut contenir n'importe quelle structure possédant une fonction ayant pour signature "manger()".
Au final, un gain de légèreté monstrueux comparé au C++ et à ses déclarations d'objets et d'héritage particulièrement verbeuses.
C'est beau, c'est simple, ça me fait pleurer !
Les autres fonctionnalités Les goroutinesBien sûr, je n'ai pas pu tout tester dans mon programme.
Je pense notamment à une des principales fonctionnalités mise en avant : la concurrence.
Mon programme n'utilise qu'un fil d'exécution. De fait, je n'ai pas pu utiliser les channels ni le mot clé go.
Toutefois, ayant déjà fait un peu joujou avec par le passé, j'ai trouvé l'idée vraiment excellente. Les channels permettant à une routine d'attendre qu'une autre lui envoie un objet pour continuer. De fait, on résout le soucis de synchronisation de manière beaucoup plus simple qu'en plaçant des mutex sur les ressources critiques !
Je suis globalement très satisfait de Go, j'ai l'impression d'un langage rapide, et ce dans tous les sens du terme :
Rapidité de compilation.
Quasi instantanée ! (dois-je comparer à un poid lourd comme C++ ?)
Rapidité de développement.
Tout va très vite. Le duck typing permet de redéfinir ses structures très rapidement, on n'écrit que le minimum.
De même, tout le monde est convaincu de l'importance des tests, mais la flemme nous fait généralement (en particulier pour les petits projet comme le mien) tester à la main la fonctionnalité sur laquelle on travaille actuellement et basta !
De fait, le système de test intégré à Go est, pour moi, un pur bonheur, tant il est simple et efficace !
Rapidité d'exécution.
Le débat est lancé ! Pour certains, le compilateur de Go est trop jeune et pas suffisamment optimisé (ce qui explique sa vitesse de compilation).
Les auteurs de Go ont notamment publié un article pour battre en brèche cette idée en montrant comment obtenir des performances proches du C++ en optimisant son code.
D'un autre côté, il s'agit d'un langage jeune, avec tous les problèmes inhérents :
Peu de bibliothèques tierces pour le moment. Au vu de la simplicité d'interfaçage de Go avec C, des projets de bindings de grosses bibliothèques fleurissent un peu partout, mais pour le moment rien de très stable/utilisable.
Un compilateur jeune.
En effet, pour le moment le runtime est compilée statiquement dans le logiciel. Cela explique la taille supérieure au mégaoctet du moindre "hello world". Par exemple, mon logiciel faisant dans les 800 lignes de Go se retrouve compilé dans un binaire de 1.6 Mo…
Enfin bon, vue la taille actuelle de nos disques durs et tant que Go n'aura pas pour vocation de tourner sur de l'embarqué, je ne suis pas sûr que ce soit un si gros point noir.
Alter Way lance sa deuxième édition de la Libre Académie. La Libre Académie est un cursus d'intégration de nouveaux collaborateurs qui comprend plus de 200 heures de formations.
Le premier bilan de ce programme a été positif. Après un choix parmi 200 candidatures, 5 personnes ont été recrutées de manière définitive (sur 6). Trois ont suivi le cursus Administrateur Système et les autres le cursus Développeur Web. Un tiers de la promotion a intégré la formation dans le cadre d'une reconversion professionnelle.
La deuxième promotion sera exclusivement orientée sur des cursus Développeurs : Web et S.I.. Deux sessions seront proposées :
Cette deuxième édition s'adresse à tout jeune diplômé, autodidacte, personne en reconversion bref toute personne qui veut travailler dans le libre.
Le Gartner nous confirme que le marché de l'intégration d'application (En anglais AIM : Application Integration Middleware) se porte très bien.
3 questions me tarabustent :
Hodjee
Hello,
Ceux qui me suivent savent que je m'intéresse beaucoup aux réseaux sociaux, surtout les décentralisés.
La dernière fois, je vous disais à quel point je trouvais la situation actuelle un peu triste: [https:]
Friendica semble, techniquement, la meilleure solution de réseau social décentralisé. Malheureusement, elle manque encore d'une interface digne de ce nom.
Comme pour me répondre, Friendica sort une version 3.0:
[friendica.com]
Au programme, intégration avec Japix pour le chat XMPP, intégration avec Twitter, Status.net, Facebook et les flux RSS pour votre flux d'informations (G+ est en prototype). Et surtout des nouveaux thèmes.
Bref, tout à l'air génial sur le papier. Reste plus qu'à tester:
[https:] (je me suis enregistré mais j'attends toujours le mail de confirmation)
Et si les DRM étaient appliqués à nos bons vieux vélos ? À quoi cela ressemblerait-il ?
C'est ce que ce texte (en allemand) de Marcel-André Casasola Merkle (@zeitweise), placé sous licence CC-BY 2.0 et dont la traduction française est lisible ici (sous licence CC-BY-SA) nous propose de vivre.
)
Original post of Marien Fressinaud.Votez pour ce billet sur Planet Libre.
La migration du blog vers Jekyll était une première étape nécessaire pour une migration complète vers une solution gratuite – ou presque. Quand le site web n’est plus qu’une collection de fichiers statiques, l’hébergement devient vraiment simple.
HerokuHeroku est une plate-forme cloud qui peut faire tourner des applications Python, Ruby, Scala etc. Le déploiement d’une app n’est pas plus compliqué qu’un git push heroku master. J’utilise la solution gratuite qui est amplement suffisante pour ce blog. Et si un jour ce blog devient extraordinairement populaire, je pourrai scaler simplement avec ps:scale web=x.
J’en avais déjà parlé sur l’article précédent, les images et les uploads divers des articles sont tous stockés sur Amazon S3. C’était pour préparer la migration sur Heroku, car on est limité à 100Mo pour une application donné. Une application dont le code source fait 100Mo, c’est déjà énorme je trouve. Et généralement personne ne stocke les uploads d’une app. web dans un sous-dossier de l’application elle-même.
Du coup ça peut me permettre de stocker des trucs vraiment énormes sans avoir de limite (sauf les limites de mon porte-monnaie évidemment). D’un point de vue argent justement, S3 est la seule chose que je paie pour héberger ce blog, et pour info j’en suis à $0.03 depuis le début du mois.
SinatraHeroku ne permet pas de déployer juste un tas de fichiers statiques, par contre rien ne nous empêche de développer une application proxy, ici Sinatra, servant seulement à servir ces fichiers. Le code de l’application est simple :
# encoding: utf-8
require 'rubygems'
require 'sinatra'
configure do
set :public_folder, Proc.new { File.join(root, "_site") }
# Last modification time for browser cache
@last_mod_time = Time.now
end
before do
headers "X-UA-Compatible" => "IE=Edge,chrome=1"
expires 300, :public, :must_revalidate
last_modified(@last_mod_time)
end
get '/' do
send_file('_site/index.html')
end
get '/*' do
file_path = '_site/' + params[:splat].join('/') + '/index.html'
if FileTest.exist?(file_path)
send_file(file_path)
end
halt 404
end
not_found do
send_file('_site/404.html')
end
Le code de l’application a été mise à jour sur le dépôt Github du blog.
Autres solutionsHeroku n’est pas la seule manière d’héberger votre blog à moindre coût. On peut utiliser entre autre :
Original post of Rydgel.Votez pour ce billet sur Planet Libre.