2 puntjes op de o mac

In most later handwritings these bars in turn nearly became dots. Since they looked nearly identical, the two glyphs were combined, which was also done in computer character encodings such as ISO As a result there was no way to differentiate between the different characters. Other alphabets containing o -diaerisis include the Welsh alphabet ,.

See double acute accent. From Wikipedia, the free encyclopedia. This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. September Learn how and when to remove this template message. Ilta-Sanomat in Finnish. Retrieved Latin script. History Spread Romanization Roman numerals. Letters of the ISO basic Latin alphabet. Letter O with diacritics. Diacritics Palaeography.

Mac Laptops : How to Use an Umlaut on a Mac

NET Core, Mono and more. NET Framework is the most used and most well-known implementation which only runs on Windows. NET, Python and more.

My Selections

Mono is also available for iOS as Xamarin. When you scaffold a Xamarin app you get multiple projects. The number of projects you get depends on which platforms you want to support. The first project is a class library which contains all the code shared between all the supported platforms. You also have one project for each platform you want to support. Those projects contain all of the platform specific code. So Xamarin code looks pretty much like the code you would write when developing a native app. It also has a switch. The code should look very familiar to Android developers.

But how about Windows? There is actually no such thing as Xamarin. Windows apps are developed the same way as you would normally develop native Windows apps. The only difference is that the app will use the shared code library which is also used by the Android and iOS apps. There are two IDEs available for Xamarin. The first one is Visual Studio which is only available for Windows and the second one is Xamarin Studio which is available for Mac and Windows. You can connect the app by using a wizard in Visual Studio see picture.

The Windows pc will send the code to the Mac and the Mac will create the iOS packages and will run the app on a simulator on the Mac, or an iOS device connected to the Mac. Developing Windows apps is only possible on Windows. If you still want to work on a Mac you can develop Android, iOS and shared code on the Mac and use source control to continue working on your Windows app on Windows.

Click here for more info on this. Later, I will write a blogpost about Xamarin forms, a toolkit to create a shared UI for all three platforms and more information about the Xamarin platform. This post will introduce you to version 2 of the Ionic framework, and help you setting up a simple App.

Hybrid apps are essentially small websites running in a browser shell in an app that have access to the native platform layer. Ionic also gives you some opinionated but powerful ways to build mobile applications that eclipse existing HTML5 development frameworks. Shortly, Ionic combines these two and adds some native look and feel to it. To see it in perspective, this is how it comes together:. But you can use any other IDE or text editor if you prefer. Open a command prompt or Terminal and run the command:. This will pull down Ionic 2, install npm modules for the application, and get Cordova set up and ready to go.

When finished it will open a browser and load the App. The folder MyFirstApp contains a minimal working Ionic 2 project. Now open home. We will create a page that shows a list of commits from Github on the Ionic2 project. Before fetching real data from Github, first create the list view. Open home. To find out what the result looks like just open this URL in a browser. These are two imports, the first imports the Http and the second one I will come back to later on. Remove the hardcoded commits, e.

In the constructor line 12 add an extra parameter: private http: Http so that the new constructor looks like:.

Establecemos nuevos estándares en el cuidado dental

So below the constructor, add the following method e. Details about Observables are out of scope for this post. This would make a good topic for a next post though. This is why we added the second import. Finally we listen to the events with subscribe. Pipes are a common way in Angular to write display values. So the line writing the date value will be:. We started with generating a blank Ionic app. And now it displays a list of commits, fetched from Github.

How this exactly works is out of scope for this post. When you start working with Ionic 2, you probably want to learn more about the concepts behind Angular 2 and Ionic 2. Signing XML in. Net has been supported since I started working with. Luckily this will change with the release of. Net 4. Hi everyone welcome to another blog post about something I recently discovered. As I was working on an application, and we were nearing our release deadline, we discovered we still had to choose a password policy. Until now, for development and testing purposes such a policy was not yet introduced in the application.

The back-end part was easy, we use a cloud provider for our authorization, so we could just set it up there. But then came the front-end part. I immediately started thinking about regular expressions, as probably any developer would. We use regular expressions for pattern matching right?

But very soon in my thinking process I also though it could not be done, because there is an order in a regular expression. That means that the regular expression engine moves through your string as it is evaluating your regex. I will give you a short example. Something like Test You would probably start with a regex that says something like:.

But this regex actually also matches just test. Because this regex says that every character it encounters should be part of this list. This is the order I was talking about earlier. As the regex engine encounters the first character of the string, it matches it against the first construct in your regex, the second with the second, and so on. So what we actually need is a regex construct that does not move our Regex engine. A construct that matches different parts, but the order of these parts is not important.

It turns out these constructs are actually there and supported by almost all of the engines that are out there. They are called Lookahead and Lookbehind constructs. This is a very simple lookahead. The syntax for a lookahead is? The part between the angle brackets can contain a regex. You can use a look ahead on every position in your regex. The regex above says :The start of the string should be followed by bar. But I can also do something like this:. This regex says the word test should be followed by bar. Now why would you use these constructs?

What does this mean? This does a couple of nice things. First, this has multiple lookaheads. You can actually combine them to do multiple evaluations, without moving the regex engine. Both of the lookaheads must be true to make your entire regular expression match. Looking at the above string this regex says. And this is something that is very hard to achieve without this construct.


So the following string would match:. So this gives us the possibility to specify conditions, in which the order is not important, but they do all need to be satisfied. Exactly what we would need to enforce passwords. And it should be at least six characters long. This is it! From the start of the string we will perform three lookaheads. Keep in mind, the order of these lookaheads do not matter! They all get evaluated from the start of our string, without changing the position of our engine.

If they are all true, the lookahead part of our regex is satisfied. As this is not part of a lookahead, this will change the position of our regex engine. An easy way to enforce password policies, this is very useful in an Angular front-end in combination with ng-pattern and ng-message to give a friendly message on your create a new user form. If we want to add extra conditions, for example at least one special character, we just add an extra lookahead.

The entire regex becomes:. Wie zegt dat cross domain iframe events en function calls niet mogelijk zijn? Als zowel de parent als de iframe source zich op hetzelfde domein zouden bevinden, gaat alles goed. Maar als de iframe source zich op een ander domein bevindt, is er sprake van cross-domain communicatie. Protocols, domains, and ports must match. De functionInParent call in de iframe source pagina is vervangen door een postMessage call. De functie bevat een parameter voor het target domain. Daar staat het domein van de parent waarin het iframe wordt getoond. In most latest browsers it is now possible to deliver different images for different devices by only one image element, using the srcset attribute.

On retina screens with a device pixel ratio of 2, the image will show the source with width of px. The browser can decide which width matches best for the device. In this case we use the size attribute, together with the srcset. Because now we tell the browser what the size will be, after applying CSS styling, and we specify the width of each source, the browser can choose the best image. The image will always be displayed with a width of px, but a retina device will choose the source with w and a non-retina device will choose the w source. The problem is that images are preloaded by the browser.

This is at the moment the DOM is not even build yet. So we have to give the browser some clue what the size of the image will be, after fully rendered and styled with CSS, for the browser to be able to pick the most suitable source from a list of sources with different widths. The sizes attribute is not the same as the width attribute. The difference lies in the responsive possibilities of the sizes attribute. A fluid design has sizes relative to the parent element. Which is not known when images are being preloaded, by the browser, before the DOM is ready and the view is rendered with CSS styling.

However there is a unit that is known, before CSS is calculated. It is the view width. With the view width we can define a fluid relative size of the image. It is even possible to use media queries in the sizes attribute. When we resize the browser window when viewing this page in Chrome we see in the next example that the breakpoint is a little surprising. When starting with a browser width of px on a retina device, Chrome chooses the w source as expected.

But it switches to the w source at a browser width of px, which I find rather unexpected! I would have expected the breakpoint earlier. Another inexplicable thing happens at px viewport width, switching to the w source. I would have expected it to happen later. Because, to be able to render a sharp retina image at px viewport width, the browser needs an image larger than px. Met dat verschil dat een SVG scherp blijft, als de afbeelding groter wordt getoond dan de oorspronkelijke afmeting Scalable Vector.

SVG is daarom ook erg geschikt voor retina devices. Omdat SVG met CSS kan worden opgemaakt en met SVG animation of met Javascript kan worden geanimeerd, heeft het de voorkeur boven een icon-font, of jpg-, png- of gif-formaat spreadsheet. Er zijn veel manieren om SVG in een website te gebruiken. Hierna volgen 6 voorbeelden.

De meest simpele methode is als image source attribuut. Nadeel is dat op deze manier de afbeelding niet met CSS opgemaakt kan worden, noch met Javascript kan worden geanimeerd. Een voordeel is dat het svg-bestand kan worden gecachet, waardoor herhaaldelijk gebruik geen probleem is. Een oplossing is om het bestand met CSS te tonen. Ook deze implementatie heeft als nadeel dat het niet met CSS kan worden opgemaakt en niet met Javascript kan worden geanimeerd.

Voordeel hierbij is, dat de afbeelding interactief kan worden geanimeerd en opgemaakt kan worden met CSS. Nadeel is dat de afbeelding niet vanuit de cache kan worden gelezen, wat consequenties heeft als er op een pagina veel of zwaardere SVG elementen inline worden gebruikt. Als een icoon of andere vorm, zoals een gradient of logo, veelvuldig wordt gebruikt, is het efficient om een spreadsheet te gebruiken.

De spreadsheet bestaat uit een container element, met daarin een node. De node bevat elementen met id attributen. Best practice is om de svg-definities de spreadsheet aan het begin van de body te plaatsen. De vector moet namelijk gedefinieerd zijn, voordat er naar wordt gerefereerd. Deze zorgt ervoor dat de vectors in de spreadsheet niet worden getoond. Voordeel is dat er geen HTML vervuiling plaatsvindt. De variabele kan door een url-encode functie worden gehaald. Na Sass compilatie is de background-image dan wel url-encoded. Toch is het voordeel van de onderhoudbaarheid een overweging van deze methode waard.

Hello again! It is time for my second blog post. Very soon after the first one, but that is because I am learning a lot these days and I am also using my blog as documentation. Normally unit testing JavaScript applications is not that hard. You will need to have a couple of components ready to make it work but there are a lot of standard frameworks and tools at your disposal. JavaScript unit tests get handled by different kind of components.

When you are creating Windows Store Apps. This because Windows runs your apps in a special sandbox that is not easily simulated by a Node, a normal browser or a headless browser. This makes unit testing Windows Store Apps created with typescript or JavaScript from your automated build almost impossible. I did some research, but I believe that the only way to run unit tests for your Windows Store App is to create a separate project that functions as a test app to run your tests.

So we are going to create a separate project in our Visual Studio Solution. This project contains all the files needed to run or JavaScript code. This means that you need to add the existing JavaScript files as links to your test project. I recommend creating just a blank Windows Store project. Once you have done this.

So any changes you make in a file will get shared between projects. This is what you want, all your changes will get tested. Next up is the choice of your JavaScript unit testing framework. I did quite a bit of research on this and I found mocha. Mocha has great asynchronous method support. So it can handle promises who finish later in a unit test without thinking the unit test is already done.

Secondly, it can easily be run inside a browser, and not only in NodeJs for example. If it can be run inside a browser, it can probably be run in an app. Because I am also working with RequireJS and Typescript it took some tweaking to get all these thing working together. First off is the HTML file. This is just a view to see our test results. Here is the code.

From line 6 till the style sheets you can see my included of mocha. Mocha supports different kind unit testing styles. I like the behavior driven development style. You will see this reflected in the way I write the unit tests. I could have also loaded these libs via require, but I did not see the point.

The rest will get loaded via requirejs, because the app I am creating tests for also uses requirejs. To see howto handle this with angular and typescript, see my spanvious blog post here. Mocha will use these to report the results. You can see the paths configuration for require starting on line three. You can see a configuration for my first test and a test for something that is called secondScreenController. On line 20 you can see the Require call, the callback will get executed after the dom has loaded and angular.

In it on line 22 I create an angular module. I do this, because the services I am going to test also register them selves in that angular module as part of their code. Without this module being there, I will get an error during testing. After this module has been created, you can see on line 24 another require call.

After they have all been in loaded in the dom I call mocha. This will instruct mocha to go and discover my tests, run them and report the results in the html file. This is a really simple typescript class. The only thing worth noting is that on line 1 I use the export keyword to define this class in RequireJS module. I do they so I can load this class in our unit test via require.

Now the interesting part. The unit test. This is where typescript shines. On line 4 you can see the import statement for my class under test. This is why in the test-main. The unit tests themselves load the class they are testing. Easy with typescript. On line 1 and 2 you can see the references to. Otherwise the typescript compiler will give you a lot of errors about the describe and should methods.

These describe functions come from the fact that I set mocha up to use BDD earlier, you can also choose another style of unit testing. You can find the actual test code in the body of the it functions. You will need to do some extra stuff for null references. You will see that in another test. That test is shown below. On line 11 you can see some null handling. This seems a bit weird but it is actually the recommended way when using should. On line 23 you see another cool feature of mocha. This is used in unit tests that have async calls.

Without the done call mocha will treat the test as synchronous. If you do that call mocha will treat it as asynchronous and thus will wait with reporting until you actually flag the test done. To finish this post. This is what I get when I run my unit test Windows Store app! I hope someone who wants unit testing in their Windows Store html JavaScript app finds this post useful. Until next time! Welcome to my first blog post for Luminis! This time I am not going to blog about. Net related stuff, as I started working on a project which uses all the above technologies together. It took a little time to get my head around it all and I bumped into quite a few things when combining these cool frameworks, so I wanted to share my findings with you all.

Typescript is a cool new language that makes it a lot easier to write structured and object oriented JavaScript. If you come from a language like C or Java you will feel right at home. It has classes, interfaces, strongly typedness and a lot more cool stuff to write your applications.

Another cool feature is that it compiles to just JavaScript! So if you have been doing a lot of object oriented JavaScript, using the revealing module pattern or class patterns to write classes and modules you will be pleased to hear that typescript takes that pain away. Now take Angular, the cool MVC. Angular has modules, databinding, controllers, services, all the cool stuff we use in object oriented languages to separate our concerns.

And that is exactly my problem, you have a cool structured framework like Angular, with an unstructured, non-oo language like JavaScript. Almost no UI, just to understand what is going on. Typescript is completely open source and already has a lot of support. In the figure below you see my attempt to set up a simple hello world controller, you can see Visual Studio, which is great tooling, does not has a lot of intellisense to offer me, even though I reference angular with an intellisense comment. This is due to the dynamic nature of JavaScript. In a minute I will show you the complete app, but this tooling trouble, is one of the problems Typescript aims to solve so stay with me.

University of Amsterdam

Now on to the complete example. Notice a couple things about this html. First of the multiple script references. This can become a hassle. The controller has to come after Angular. The order of the scripts matter, when I create a lot of files and dependencies this becomes hard to manage. Will solve this later using RequireJs.

Further more on line 8 I am using the as syntax to define a controller. Notice the whole anonymous function part? This is the JavaScript pattern to define a class. In JavaScript a class is basically just another function. This is a lot of work for just a class! Look at this! Very nice. And this just compiles to plain JavaScript, so in the browser you will just reference the same. The controller still needs to get registered in Angular.

As Typescript is a superset of JavaScript we can do the Angular registration below the class definition, or in a separate typescript file. The only problem is that we will get compiler errors as the typescript compiler does not know about Angular or, other normal JavaScript libraries. To get Typescript to play nice with Angular and other JavaScript libraries you can make use of so called definition files.

These are basically descriptions of a JavaScript library so that the Typescript compiler knows which functions there are, what they return and parameters they have. You can create these, there is a big tutorial on these on typescriptlang. When you use Visual Studio you can right click on a JavaScript file and download the files from there.

  • add apache tomcat to netbeans mac!
  • photoshop c6 free download mac?
  • usb sim editor for mac.
  • Categorie: Technical.
  • Áreas de negocio!

I created a screenshot of my Visual Studio just to let you see how cool this is. In the top of the file I reference the Angular definition file. Now Typescript knows of the angular variable and gives me complete intellisense about types, function etc.

Helpful answers

You can see this function returns an ng. IModule instance, on which we also get complete intellisense. Here is the complete code. Keep in mind that this is just compile time. Run time the scripts still need to be included in the right order to make sure the angular global exists before our controller registration. What is also cool, is that if define parameters in our constructor, they will get inject by angular.

We could let inject Angular all kinds of registered services just like with normal controller functions! Here is the code for our alert service. Our service implements an interface, so we can easily switch it for a service which uses bootstrap for example. Also on line 14 you can see the angular registration. Yes Typescript has lambda expressions!

The difference with a normal anonymous function is that the lambda keeps the this pointer of the parent function instead of a new scope. Now the service needs to get injected in our controller. The html will follow later. On line 5 you see a cool Typescript construction. For a constructor parameter that has a modifier Typescript will automatically emit a class variable. If the name of our parameter is the same as the name of the registered service Angular will just inject it. If not, when you use minimizing you have to use another inline annotation for it to work.

You can also see the dependency on the services module when loading our appmodule. Keep in mind that this is not a file dependency. That is still up to us. Look in the html next, there we will need to include the scripts in the right order. You can see, starting on line 6, the script tags. They have to be in this order or the app will break. On top of that, the browser will load all these scripts, even if there are services included that the user does not need because he does not touch the functionality tat requires these services.

Enter RequireJS. This is a library that adds modularization to JavaScript applications. Uhm wait, modularization? Yes it does! But Angular has logical modules. Angular does not modularize the file loading for example, or the handles the file dependencies as you can see in our index. Require can work neatly together with Angular modules, keep in mind that both libraries solve different problems. I am going to add Require to my application.

The first thing that will change is my index. Two things that stand out are there is only one script tag left in our html.

Establecemos nuevos estándares en el cuidado dental

That is the reference to Require. As Require will manage all our script loading, this is the only thing we need in our main html page. The second thing is the data-main attribute on the script tag. This tells Require where it should start with executing. Very comparable to a main function in C for example.

First in our main js file, I call require. We can use this function to give require some extra config stuff. Like short names for libraries. My call tells Require that whenever I want to use angular, it can be found by following the path I pass to it. On line 8 you see another cool thing. Require loads JavaScript files and sees them as modules. But those JavaScript files ideally should know that they contain Require modules.

When defining an Require module a JavaScript file should tell Require what it is exporting and on what other modules it depends. We shall have a look at that later. The problem with angular is that this is an existing JavaScript library that does not contain Require modules. Angular just populates the global scope with an angular variable. By using a shim, we tell Require that when angular is done loading, it should clean up the global angular variable and instead pass it to the function on line This is because I made a little modification in our appController.

Couple of cool things here. On line two you can see a typescript statement that is unknown to us. This is an undocumented feature of typescript. This statement allows us to specify the Require dependencies of our current module. On line 4 you can see the import statement.

This makes sure I can use types from the module and the module itself in my code. On line 6 you can see an export keyword. This instructs the Typescript compiler to define a Require module that exports our controller. On line 16 you see that we need to import angular to make use of Angular. Just as with our alertService we want to make use of the angular module, so we add an import statement. This leads to compiler errors however. So we need to write a new definition file that tells typescript that angular is loaded as a Require module, and from that module exports the angular variable.

Basically we need to make Typescript aware of our Require configuration in our main.

  1. Liebherr- international Group & family enterprise.
  2. fix margins on microsoft word mac;
  3. Pick Your Language!
  4. kitty powers matchmaker download mac!
  5. Superscripts and subscripts.
  6. Here is the. You can see the file getting referenced on line 1 or our controller and also in our alertService. Just as the shim configuration for require in the beginning of this post. The alertService is defined below. Nothing strange here. It is just like our controller.

    We use export to export the different types from this module. But there is still something strange happening. The problem here comes from the fact that Require loads and bootstraps angular before the DOM is ready. What we want, is a way to tell require load the modules as soon as the dom is ready.

    Fortunately there is a way to this. This is actually a RequireJS plugin called domReady. It is really cool. Just download the domReady. And make the domReady a module dependency of your main module. Here is the modified main. You can see that when you add domReady as a dependency, it will give you the current document as a parameter to your module function.

    So now we are done! Typescript makes working with require a lot easier, but you do have to know how Typescript accomplishes this, and how to make use of the. Yes, this is a somewhat long article. With no images, code samples, fancy screencasts or other visuals. It is just a story about me and my passion for OSGi. Perhaps there will be sequels, because there is still a lot to come.

    However, these intentions always seem to vanish over time so I am not making any promises. In any case, I felt the urge to share my thus far little experience with real world OSGi. For a real customer with a real product on a small budget. Where software is developed by Average Joe or Jane and not by some cracker jack software guru flying around the world doing talks and publishing books. These people are of course working hard to make our life a better place while we just gloat over travelling abroad and back cover blurbs. In short: The customer has a product consisting of a central server with a number of embedded devices connected over the internet.

    The server is a plain Java application with a Jetty web interface to operate, configure and monitor the system. In the near future, we want to extend the capabilities of the system and will of course result in more network and other domain related complexities. When I started working at this project, a rudimentary rest interface for the server was already present and one of my jobs was to extend it to a full working version.

    Of course extensive testing was required, so I started by developing a simple tool to test a live rest service. It was sufficient to just let it fire a bunch of predefined http calls and log the results. I could extend it by automated validation and other should-haves later on. Eager to show off I started hacking away and the first requests were sent within the hour. Hardcoded urls launched from a static main method was the result but who cares? It was just a simple tool right?

    Next to a command line interface, repeatable tests or extensive logging could soon be needed. Such requirements were still uncertain and not that essential for the current state of the project. However, I did not want to rule them out by making it too hard to code in at a later stage.

    If you are not thinking OSGi already you are not paying attention. What is more is that OSGi would be extremely useful for a new software version on the embedded devices. So the more hands-on experience, the merrier. When it comes to OSGi, Bndtools is the only viable way to go, trust me. Unfortunately only available as Eclipse plugin yet, but the future is bright. Eclipse still has a grudge ever since I abandoned it for IntelliJ and I feel like I am still paying the price.

    But Bndtools is a loyal companion and creating bundles with correct dependencies, setting up run configurations, debugging and headless build support is a breeze. Marcel pointed to JPM and suggested to include the required bundles in the local workspace repository and just commit them in Git. For the Bndtools novice: You can set up local and remote repositories for external bundles. This allows you to easily setup package requirements for your own bundles.

    These files with clear methods definitions always make me smile. With a fluent API I was managing services like a skilled puppeteer. That is until you try to set up the run configuration and Bndtools is giving you a bit of a cryptic error when you hit the resolve button. Apparently I was missing some packages required by the dependency manager. Are these like meta dependencies? Anyhow, the video tutorials from Amdatu provided valuable help.

    It worked, but it was not ideal for a software engineer wanting to show off and just needed a quick fix.