text:
Space Nuts Disc 2 From Wicked Pictures
This movie features Jayna Oyso Julie Robbins Renee Pornero Sophi and Taylor Rain! Two dudes and one chick join in every scene for a sexual adventure where no hole is discouraged! BackEnd Productions is back with Myspace. So two women come off the tennis courts after playing; both are sweaty and in need of a … Continue reading "Space Nuts Disc 2 From Wicked Pictures"


text:
We got there as a team and now we want to share our practice and insights to the developer community.
There is very interesting topic on StackExchange Programmers: How do you dive into large code bases?. In that topic the summary of all answers to the subject question can be boiled down to the points:
I read this as that documentation is always recommended as starting point for exploration. This can be a documentation for a code base a developer has to dive in at new job, documentation for a project a developer is suddenly switched to, documentation for a big open source project. In all of these cases having at least a high level overview of what is going on in code or in a problem domain is nice, or sometimes must, to have.
It took a while for us to realize that documentation can be integrated into a developer workflow in the same way as Test-Driven Development is integrated: we call this "documentation first development" or jokingly "documentation-driven test-driven development".
Before writing new or modifying existing code we review and adjust documentation. We try to make a source code correspond to business requirements as much as possible so that they can be traced directly to the source code and we do the same for documentation: we document requirements, green and red cases, gotchas, hacks, test cases etc. "Documentation first" clamps our workflow: documentation is constantly read and updated along with writing new or modification of existing code.
One of the most common arguments against writing a documentation is that documentation easily becomes outdated and irrelevant.
Based on my limited experience of working in different teams and on different projects with or without, I think that to create healthy documentation ecosystem where the whole team is involved it should be more than 50% of proactive team members who are willing to write and maintain documentation i.e. it should be the majority.
Given a documentation is not a single developer effort, it is quite easy to fix irrelevant documentation you work with: as long as you see the documentation is outdated, you go and fix it and that's it. If enough people contribute to documentation ecosystem, it is never outdated, the rest is a matter of luck of having such intelligent and responsible majority in a particular company, team, project etc.
Our tool of choice for documentation is Confluence. We use it at its full power: we use its formatting primitives extensively, some examples are: Panel macro, code blocks, info and warning macros, graphs. We experiment with everything that makes documentation readable and pleasant to look at and work with and share with each other what we find.
At some point we also considered using in-source Github documentation or Github Wikis but decided to continue using Confluence as it was a company's standard more accessible by our less technical colleagues.
The following are only a few examples of types of documentation we have.
Each feature of mobile app is documented on a separate Confluence page. Most of the times feature is documented as a sequence:
Every time we asked or are asked a question and we don't know an answer or catch ourselves answering it more than 2 times, we add question and answer to the FAQ. The question can be related to understanding the difference between how A-B bookings are handled versus hourly bookings or the details of a payment edge case.
Not only our QA documentation contains QA-specific docs about test devices, test data (fake credit cards, testing vouchers etc), testing tools but also our QA engineer directly contributes to documentation along with developers. It happens very often that based on feedback from QA rounds we clarify missing or confusing pieces in documentation.
The following are two inter-related features that I think we are missing as they could additionally complement our existing documentation workflow.
The only thing I am missing in Confluence is that documentation hosted along with source code would be more tightly integrated with a project's lifecycle, especially its versions. It is not only about seeing revisions of a document, which Confluence provides, but rather about being able to revert to specific version of application to see the state of docs there. But since Github is not an option for non-developers, we don't have an opportunity to experiment with this practice. Fortunately enough, so far we didn't encounter any serious issues related to back compatibility in code or critical changes in business decisions so this problem is not critical at the moment.
This one, I think, is more important and relevant to our work: it is quite hard to come up with a document (or group of them) that would allow us to see and learn from history of development of our products and business in general. A knowledge about domain with long history can be very diversified and spread across different teams, departments, companies so it is hard to maintain complete integration of a whole process. So far we are proud of and confident in our evolving mobile documentation ecosystem however we are still missing this kind of better integration with the rest of domain knowledge other departments have. I believe this is very interesting problem that can only be solved with a team effort as it is hard to imagine a dedicated single man position for this kind of work.
Documentation ecosystem is our mobile team's effort and I have never had a chance to work in a team with such a strong focus on business domain before joining Blacklane.
I would like to say a big thanks to my colleagues with whom we work on documentation that makes us more informed and thoughtful about our domain and helps us challenge the complexity of the problems we work on.
It is very often that documentation may seem redundant, however if you work in complex domains with a long history (even relatively simple domain with a long history can easily become complex) or deal with large codebases, well written documentation can be your only torch in darkness.
Documentation ecosystem is a team effort, not a single man's - everyone should care about domain and contribute to an ecosystem. It is a pleasure to work in a team, where the knowledge is shared and trusted and helps you to solve business problems with a technical skills you have.
Let your project have a good documentation!]]>
In this part I will again focus on some other highly interesting gems Mutant uses, in particular the Abstract Type gem and the Adamantium gem.
Abstract Type gem allows you to declare abstract type classes and modules in an unobstrusive way:
In programming languages, an abstract type is a type in a nominative type system that cannot be instantiated directly. Abstract types are also known as existential types.An abstract type may provide no implementation, or an incomplete implementation. Often, abstract types will have one or more implementations provided separately, for example, in the form of concrete subclasses that can be instantiated. It may include abstract methods or abstract properties that are shared by its subtypes.
When would you use an abstract type?
Think about your typical web shop. You might have a base user class with some common methods:
1 2 3 4 5
And then you have 2 other, more concrete classes like this:
1 2 3 4 5 6 7 8 9 10 11
You never intend to actually instantiate an object of a
User, only of
RegisteredUser and
GuestUser, so
User is an abstract type (this is also called the template method pattern).
However in its current state every other user of your classes, e.g. your fellow programmer sitting next to you, could instantiate this class accidentally and introduce a subtle bug in your application since this object would probably be usable in some senses but in other not.
Abstract Type you would fix this like this:
1 2 3 4 5 6 7 8 9 10 11 12
This will not only prevent bugs like above but also - and for me this is even more important - communicates your intention clearly. There's no guessing here. It's immediately clear that
User is not supposed to be instantiated.
At this point you might think "But wait a sec, if you can't instantiate a user, what's the point of that
abstract_method call?".
Excellent question!
Ruby being, well, Ruby, there are of course multiple ways to instantiate objects. You could use allocate for example:
1 2 3 4 5 6
So how does it work? Let's start with the
include statement and then work our way to
When you call
in your class this will prompt the Ruby runtime to call the
included callback that is defined at the top level of the gem:
1 2 3 4 5 6 7 8 9
create_new_method looking like this:
1 2 3 4 5 6 7 8 9
Ok, there is a lot going on here, so let's go through it step by step:
We're dynamically overwriting
Class.new in the class that we intend to make abstract. The important part here is that this
new is also what will be used when we call
new on subclasses but it doesn't affect the "original"
new in all other, unrelated classes. That's because of Ruby's "one step to the right, then up the ancestor chain" method lookup.
If you're confused now I'd recommend to stop reading this article and to read up on the Ruby object model and especially on Ruby's method lookup and then return here.
Ok, ready to continue?
In the new, uhm,
new we fail if
self is equal to the abstract class. The equality check here is based on
BasicObject#equal? which checks for strict identity. Also note that we are not using
raise here but
fail instead (which is just an alias for
raise), something that is kind of controversial in the Ruby community.
When we're in one of the subclasses of our abstract class this guard will fail in which case we're just delegating to the original
With this out of the way let's get back to the
included callback:
1 2 3 4 5
descendant (read: "base class" this module is included in) is extending the
AbstractMethodDeclarations module here, thus adopting its methods as singleton methods (or class methods in layman's terms).
One of those methods is the
abstract_method we saw in the example at the beginning:
1 2 3 4
This is the method that allows you to declare your abstract method a la:
A bunch of interesting things going on here. First of all, we're using a neat little trick that is kind of the reverse of Ruby Symbol#to_proc feature.
basically means
1 2 3
and heavily relies on
Method#to_proc. You can read up on how this works here.
self at the end
1 2 3 4
allows you to chain calls to
abstract_method (of which I don't really see the point here since you rarely chain class macros, but I guess the author follows his own conventions in this case).
And what does
create_abstract_instance_method do?
1 2 3 4 5
It defines an abstract instance method that will do nothing but …. fail with a proper error message.
Exactly what we need to implement abstract types.
Note that there's also a sister method to
abstract_method that's called
abstract_singleton_method which does the same thing for singleton methods which I'm not showing here for the sake of brevity.
Adamantium allows you to make objects immutable in a simple, unobtrusive way.
Sounds a lot like the IceNine gem I covered in the last part of the series, doesn't it?
Well, it kind of is and it kind of isn't.
Adamantium uses
IceNine under the hood for the actual freezing. The real value of
Adamantium comes from offering high level strategies that you can easily apply to your objects where
IceNine is more of the functional base library.
Why would you need immutable objects?
With the resurgence of functional programming these days people talk a lot about "immutable data". Immutable data structures are one of the core tenets of functional programming and something that is notoriously hard to get right in Ruby.
Imagine you have a bank account model like this in Ruby:
1 2 3 4 5 6 7 8 9 10 11 12
In its current form, every other piece of code in your application could mutate it like this:
1 2 3 4 5 6 7 8 9
Adamantium to the rescue!
1 2 3 4 5 6 7 8
Now watch what happens when I try my shenanigans from before again:
1 2 3 4 5 6 7
Adamantium offers 3 strategies for freezing your objects:
The default strategy is
deep. Here's the example from the README:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
And now let's contrast this with the
flat strategy:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
For the sake of brevity, we'll exclude the
noop mode and focus on the
deep and
flat mode.
Let's start our investigation with the
included callback for the
Adamantium module:
1 2 3 4 5 6 7 8 9 10
included gets passed in the class it is included on called
descendant and then re-opens this class using
We then include the
Memoizable module (which I won't cover here) and extend
ModuleMethods and
We'll start with checking out
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
freezer methods determines what strategy to use. As I already mentioned above you can see that
deep is the default strategy. And then there's the
memoize method you saw being used above in our example from the README.
There's quite a lot going on in this method so let's step through it line by line:
That's a neat trick right there. This allows us to write
1 2
and it will still work out.
Note that you couldn't do this just with Ruby's default arguments:
1 2
You could achieve the same using Ruby's keyword arguments like this:
but I assume this code was written with Ruby < 2 in mind which didn't support keyword arguments.
Next we determine the freezer to use via the options or use the default freezer (which is
deep like already mentioned):
We then iterate over all the methods the object in question has and freeze them via
only to return
self at the end
so we can chain the
memoize calls if we like.
Let's check out how the actual freezing is done:
1 2 3 4 5 6 7 8 9
Ok, so the deep freezing is delegated to IceNine on which you can read up here.
One thing I'd quickly like to talk about though is this:
1 2 3 4 5 6 7
Deep inherits from
self. And what is
self here?
1 2
is actually a fancy way of writing
But why are we doing this here instead of being explicit? It's making our intention explicit without duplicating names across our module. And even if you rename
Freezer to something else, this line doesn't change, which makes it easier to refactor and less error-prone to subtle bugs.
Is it a huge deal? No. It isn't. But in a larger code base small things like can make the difference between "barely maintainable" and "updating functionality is a walk in the park".
Before we wrap this up here let's look at one last thing:
We saw how the default strategy is applied. What about that the
flat strategy?
A quick reminder to how applying and using the
flat strategy looked like:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
As you can see, you just include the
Flat submodule of
How is this implemented?
Let's look at the
included callback:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
That's pretty cool. Let me walk you through it:
1 2 3
We're calling
instance_exec on the descendant and pass
self in. What's
self now?
It's the module constant, so…
We then include
Adamantium. That is something we already covered above in this article. So business as usual.
But then we extend
mod, so
Adamantium::Flat. Why? Because this basically overwrites the
freezer methods that we imported in our class by doing
so that this now returns the
flat strategy
1 2 3
not the
deep strategy
1 2 3
So long story short, this is just a very advanced configuration mechanism. Granted, it might seem a little complicated but at the same time it completely separates the modules from each other making it easier to update one without updating the other.
What we discussed today:
AbstractType for base classes you do not intend to instantiate
Adamantium offers high level strategies for making your objects immutable
That's it for part of this series. Both gems we looked at in this article are pretty small, but packed with a lot of features.
In the upcoming part 4 I will be looking at the enterprise gem from Aaron Patterson because currently the Ruby eco system is definitely not leveraging the power of xml.]]>
We'll continue to look at some other highly interesting gems Mutant uses.
Initially I had planned to cover multiple gems again, but after starting to look into the IceNine gem I realized that this was big enough for its own blog post.
IceNine is a library for deep freezing objects:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
In recent years, functional programming has become all the rage and how to introduce it into languages that are actually not functional like Ruby.
Depending on who you ask, everybody has a different definition of what "functional" means. Me, I have 2 attributes that I count as essential for a functional language:
I believe Ruby will never have pure functions in that sense but you can create immutable data structures in Ruby by calling
freeze on them. However, just calling
freeze on an object doesn't deep-freeze it as you can in my initial code sample above.
And that's where
IceNine comes in.
Immutable data structures might not be applicable everywhere and all the time but quite often they offer significant benefits over mutable data structures, for instance:
With the rationale out of the way, let's check out how it works!
In my example above you could see that using
IceNine boils down to:
Here's the relevant part of the
IceNine module (defined in
1 2 3 4 5
Ok, not much to see here, we're just delegating to
IceNine::Freezer (defined in
1 2 3 4 5 6 7
Let's ignore that recursion guard thingie for now - we'll talk about this in detail later - and go further down the spiral:
1 2 3 4 5
There it is. That's where the magic happens.
Let's dissect this line:
First we need to understand:
object is the object that we passed to
IceNine.deep_freeze in the beginning:
So the
object would be
and thus
object.class would be
And what does the
[] method look like?
1 2 3
Now things are starting to get interesting. This
@freezer_cache is defined at the top of the file:
1 2 3 4 5 6 7 8 9 10 11
The code above is terse and gets a lot of work done:
We set up
@freezer_cache as a hash. Note that
@freezer_cache is not an instance variable but a class instance variable which means this assignment gets executed when Ruby reads the
Freezer class since Rubys class bodies are executable.
We pass a block to
Hash#new. In case we ask the cache for a key that doesn't exist this block will be called with the hash object and the key and should return the default value (see the Hash docs)
So the block parameter
cache is the hash itself and
mod is the class of the data structure we passed to
IceNine, so
Hash here.
We then traverse the ancestor chain up and look for a corresponding freezer. Sticking with the hash example we would immediately find
IceNine::Freezer::Hash since the first link in the ancestor chain of any class is….the class itself as you can see here:
1 2
Long story short: Given a
Hash this could would find the - surprise! -
Hash freezer.
Obviously this is kind of the most possible simple example here since there are a lot of edge cases where it's not that easy. I won't go into the details here though and focus more on the high level (I also won't go into the details of how
find looks since that is a tad more complicated but you can go and check it out in
Now, equipped with a solid understanding of how the freezer lookup works let's come back to
1 2 3 4 5
and especially:
We now know that
part so let's look at that part:
and imagine that
would have returned an
IceNine::Freezer::Hash like we had done in the paragraph above.
This is how
IceNine::Freezer::Hash.guarded_deep_freeze looks like:
1 2 3 4 5 6 7 8 9 10 11
Let's see what
freeze_key_value_pairs is all about before looking at what happens via
1 2 3 4 5 6
Ok, that's pretty simple, isn't it? We iterate over all keys and values of the hash and deep freeze them as well.
Now what's up with
As you can see above in my initial
IceNine::Freezer::Hash snippet this class inherits from
1 2 3 4 5 6 7 8 9 10 11 12 13
Now things should start to make sense:
freeze, and if it does, we'll freeze it.
1 2
Hash they keys and the values
Ok, so now we know:
This only leaves one thing left to explain: What's up with that recursion guard?
If you paid attention, you'll have noticed that
IceNine recursively traverses any data structure you pass it in.
Remember that we started out like this in
1 2 3 4 5
And we then restarted the whole cycle of getting the objects' class, determining the appropriate freezer, freezing it and so on in
1 2 3 4 5 6 7 8 9 10 11 12
So there's the recursion that we start via the recursion guard.
Why does it say "guard"? Because you might create and pass cyclic data structures like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Without a recursion guard
IceNine would recurse down until you'd get
Let's check out
IceNine::RecursionGuard::ObjectSet(defined in
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
The code above is incredibly simple and yet incredibly powerful at the same time.
First we get the
object_id of the object we're looking at:
Now the important part: If we have seen this very object already this means we're indeed traversing a cyclic structure. In this case, we just return:
If we made it until here we'er seeing this object for the first time, so we store its'
And finally we yield to the block:
deep_freeze available to all objects
IceNine also offers a core extension in
1 2 3 4 5 6 7 8 9 10 11
First we define a separate module following the convention that modules that are mixed in into core classes are defined under the
core_ext scope. What this module does is pretty simple, it just calls
IceNine.deep_freeze and then passes
self to it. What will
self be? Modules with instance methods can not be used standalone but only as mixin. Means, mixed into a class. So
self will be the class that we mixed it in.
How are we activating this?
This effectively makes
deep_freeze available to all objects in Ruby's object space.
By the way it doesn't matter if you use
class_eval or
instance_eval in this case.
have the same outcome here. This would however make a huge difference if you defined
deep_freeze on
Object via
def directly.
E.g. this
1 2 3 4 5
deep_freeze on an instance level since
class_eval just re-opens the class. So we're good.
This however
1 2 3 4 5
would not work since it would create a singleton method (read: class method), not an instance method.
So you should be aware of those differences.
Most gems I have seen use the
Object.instance_eval trick for
core_ext and you probably should follow this pattern in your own gems.
So let's summarize what we learned today about
That's it for part of this series. In the upcoming part 3 I will be looking at the Adamantium gem and the abstract_type gem.]]>
While browsing the source code of Mutant and of the gems that Mutant uses I realized that those codebases are among the cleanest code bases I have ever seen in Ruby land with an amazing overall architecture and I'd love to share what I've seen and learned reading their code.
I intend to make this a series with the first part of this series not covering Mutant itself but the gems it uses.
Let's get started with Mutants gem dependencies.
Concord is a nice little library that helps you turning this:
1 2 3 4 5 6 7 8 9
into this:
1 2 3
What's interesting here is how we we include it:
Ok, something is including a module. Wait, it's not a module. We're calling new on it. Wat? How does this work?
Here's what happens when you try to include something that is not "module'sque":
1 2 3 4 5 6 7
Ok, makes sense. Foo's class is Class, not Module.
Let's contrast this with a proper module:
1 2 3 4 5 6
Now let's try to emulate the code I showed you from Mutant:
1 2 3 4 5 6 7 8 9
Now it gets even more confusing - include Foo doesn't work, include Foo.new does but the class of Foo is still Class not Module. What's happening here?
Let's see how Rubinius actually handles this in module.rb (the behaviour below is identical to MRI Ruby):
1 2 3 4 5 6
There it is. If the argument is not a module or if it's a class we raise.
Now we understand why include Foo doesn't work - because it's class is Class - but include Foo.new does not raise - because its class is Foo, not Class.
This elegant trick of having a class inherit from Module allows us to use a class in a kind-of module context and to use a module in a kind-of class context. To put it differently, this allows a module to have an encapsulated context (its instance variables), that does not leak into the ivars of the class that includes that module.
Interesting side note:
Concord has a limit of 3 arguments. Intentionally hardcoded. It'll not accept
The idea is that because
Concord creates a positional arguments interface constructor, the limit of 3 guarantees you do not overuse
Procto turns your ruby object into a method object. The code example from the README speaks for itself so I'll just paste it here:
1 2 3 4 5 6 7 8 9 10 11 12 13
The code to make this work is surprisingly small and very elegant.
Let's start with looking at this part
from the example above without paying attention to what happens when it is included:
1 2 3 4 5 6 7 8 9
We define a singleton method called call that takes a name and returns an instance of Procto. (Using the same "include a kind-of class as module trick" Concord used above).
How does the constructor look like?
1 2 3
Here things start to get interesting. We use a lambda (via the stabby lambda syntax) that takes an arbitrary number of arguments. And then it calls new with those. What new does it call? The block is executed at runtime and in the scope of….the object that Procto is included into, so the new here is not Procto#new but rather the object it has been included into.
In other words, the lambda will create a new object of whatever it is included into and call whatever name we pass into it.
That's basically the
So what happens when this is included?
1 2 3 4 5 6 7 8
We're using the included callback here (note that it is not self.included here due to using the kind-of-class-module set up).
In this callback, we're using instance_exec on the host class, which would be Printer from the example above. This effectively puts us at class scope.
Furthermore we pass our @block instance variable to BasicObject#instance_exec which instance_exec then passes as block-local variable block to the, uhm, block (sorry, that's a lot of "block" in one sentence, I know).
Note that this is not a typo: We need to pass @block explicitly to instance_exec because instance variables will not be visible in the block that instance_exec takes (for details see here, here or here).
Now by using Object.define_singleton_method we define the singleton method call (or, in layman's terms: class method) so we can finally do
Equalizer is a module to define equality, equivalence and inspection methods.
An example from the README:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Without the include from above Ruby would evaluate this as false, not true.
When can this be useful?
Think about value objects:
A Value Object is an object that describes some characteristic or attribute but carries no concept of identity. As there is no identity, two Value Objects are equal when all their attributes are equal. An example of a Value Object would be Money.
Value objects are heavily used in methodologies like Domain Driven Design or when using composed_of in Rails (for a great introduction to this whole topic, check out this article series from Victor Savkin).
How does equalizer do this?
Let's look again at how it is included:
Pattern looks familiar, doesn't it?
Ok, let's check out the initializer:
1 2 3 4 5
Nothing really to see here so let's check out define_methods:
1 2 3 4 5
Let's focus on define_cmp_method and ignore the other two methods for now:
1 2 3 4 5 6 7 8 9
This whole chunk of code looks a little more complex than it actually is:
We define a method called cmp? that takes something that will denote the actual comparison and then other, so the thing we are comparing it to.
We then check all keys (read: attributes) and if they satisfy this monster:
What's happening here?
__send__(key) will basically just return the attribute key points to
attr_on_object == attr_on_other_object
Not so complicated anymore, is it?
With this out of the way, how is it used?
1 2 3 4
So first we check if the objects have the same class.
Then comes the interesting part: We call cmp? and pass
__method__ to it which is a special identifier that Ruby sets up for when you enter a method and that gives you the actual method name back.
So we could have also written:
Why on earth would you then just not write it that way, you might ask?
There are multiple reasons for this. First and foremost, it communicates intent clearer. Whoever reads this just knows that you are referring to the same thing. Second, it makes it easier to refactor - in case you would change == to something else you could leave the rest of this method untouched.
With this quick digression, let's come back to this one:
1 2 3 4
Taking into account what we talked about above it's now obvious what it does: It takes the other object we're comparing our current object to and calls == for comparison of all attributes both objects have in common.
So what did all 3 gems have in common?
The top level class was inheriting from Module so if you take only one thing away from this post it should be this neat little trick that kind of blurs the distinction between classes and modules in Ruby even further and that can help to increase the elegance of your code significantly in my mind.
That's it for part of this series. In the upcoming part 2 I will be looking at the IceNine gem.]]>
It may seem that we're pretty safe if we have tests and follow the specification. Well, actually no. Usually it works well in theory, but doesn't really work in practice.
We can write as many tests as we need to cover all edge cases, but that is both time consuming and error prone. The best choice would be is to automate this process.
So we made a small library to make our life easier - Fuzzer.
The basic idea is to generate many many derivatives of original sample data and feed it to a consumer.
For instance, from this sample
1 2 3 4
we could get two mutants by using
ReplaceNode mutation, such as:
1 2 3 4
1 2 3 4
There are many decisions our serializer/mapper/whatnot can make when it gets such a result: return an error explaining why it cannot convert the dictionary into a model, or silently ignore "number" field, or any other action. In general this decision is up to you and your domain model.
But I'm pretty sure there is no domain model that accepts exceptions like
-[__NSCFNumber length]: unrecognised selector sent to instance 0xDEADBEEF.
The use case may vary and depend on a workflow. The recommended way is to create another test target and put these verifications there.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
It's not very elegant, but it does the job very well.
Lines like
user.name.length; may look weird, but it's the easiest way to validate that
name is
There might be a category
NSNull+length or
NSNumber+length, but AFAIK our team members doesn't have such mutations.
Example looks pretty straightforward, but I'd like to highlight couple of things.
The block here does nothing but catching exceptions and recording them into internal storage within mutant that caused the exception:
The engine records only failures, so it's enough to assert count of returned reports. One can easily examine what caused failure by looking at report, e.g.:
1 2 3
The library provides just a couple of built-in mutations.
Returns sample without some node so that
1 2 3 4
becomes either
1 2 3
1 2 3
This mutation replaces value of some node with another, 'random' value as shown in the very first example above.
'Random' quoted not because of nature of 'randomness' in general, but because the replacement can be provided using
NodeReplacement, e.g.:
1 2
That is, mutator will generate mutant with this replacement for each key/value.
The library provides finite set of built-in mutations and replacements which is, probably, not enough for real life usage.
Fortunately, there is an easy way to extend it.
Previously we were changing only content of sample dictionary, now it's time to go deeper (actually shallower).
Let's create a mutation that will return random value (using
NodeReplacement) instead of changing a sample.
Simplest interface ever:
1 2 3 4 5 6 7 8
Implementation is not sophisticated as well:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
The usage is trivial:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Please, don't crash when your server lies!
P.S. I do consider to include
ReplaceSampleMutation into the set of built-in mutations.
I will be more than happy to review the Pull Request.
Germany, the country I was born and live in, is a quite bureaucratic one. There are forms for everything. It doesn't matter if you want to get the medicine the doctor recommended, apply for tax correction, signup for a bus ticket subscription or get your travel expenses reimbursed at work — there is a form for it, and you have to use it. No exceptions.
But it doesn't end there. These forms can take up to 40 pages. The form design language and the field label language are highly cryptic and not user-centric. Sometimes it even makes a significant difference if you put a seemingly harmless zero-value in a form field instead of leaving it empty. Filling this out can be a tedious process. And there is always some mistake you made, that you only find out about when you try to submit it. Apparently is multiple degrees harder when you're not a native speaker or not familiar with the topic of the form.
In 2008 Google, which already had released Google Docs and Spreadsheets, released a new tool called Google Forms. Forms allows you to create a form on the web, where multiple users can fill it out, and the results are saved in a spreadsheet. There is also some analytics available for it. This form is a web form, so how can it be connected to the real life forms in a way that is more user centric?
Let's create an abstract user story:
As a person who needs to fill out a form I want a filled out form based on questions I can answer so that I can submit the proper filled out form.
But nobody cares about the form itself. So let's take a more concrete example:
As an employee of my company I want my travel expenses form filled out properly so I can get reimbursed for my business lunch.
The process for creating a user centric process to solve this problem is clearly target driven, as the expenses sheet that needs to be submitted is a nonnegotiable document format constraint by laws and regulations. The technical challenge is, to hide as much as possible of this process from the user. Whenever I am challenged with minimising a process for a user, I imagine how this process would look like if a very important person had to do it and some helper gets very short time to get the crucial information from this VIP. For most processes, the solution would be for the helper to ask a prepared list of questions to get a set of minimum viable data, then the helper prepares everything on his own time in a way that the VIP only has to approve it or give more feedback for another adjustment round. Once it is approved, it is signed by the VIP.
For a user centric solution for the travel expenses form it means, we need a minimal set of questions to ask and from that create a printable document that can be presented for approval via signature. Or in a more technical language:
We want to build a web form that asks for the travel expenses data, create a PDF based on a travel expense form template filled out based on the data we got, and email this PDF to the person who filled out the web form.
To build this process, we start at the end and go mostly step by step backwards. So the first step is, to obtain a copy of the spreadsheet with the travel expenses form as it needs to be printed. It probably looks something similar to this:
In the next step we need to find out, which fields have to be filled out with which data, so that the form is properly filled out for submission. We go and talk to person who knows best about it, probably someone in the finance department. From that interview we create a list of questions to ask, which get us all the answers that allow us to fill out the form. Then we analyse this list and kick out all questions that give us data that can be obtained otherwise, via calculations or calendars, for example something like
Day of submission — we know the date of when the web form is filled out, so we can assume that this will also be the day of submission. The fewer questions the better.
With this list of questions, we want to create the web form. So we open the spreadsheet with the travel expense template, and go the menu bar to the menu item
'Tools' and select the first item:
'Create a form'. This instantly creates a scaffolding for the new web form. A new sheet is added to the spreadsheet, where all the submitted data will be stored. And a new page is opened for editing the new form. With the new Google Forms it looks something like this:
With this user interface we can easily add more questions. We could add date-pickers and put constraints on the answers that are allowed. All the details on how to do things like that to build an optimal form with low probability of misunderstandings and errors can be found on Google Help. When you're finished and try submitting the form with the first test data, it ends up in the new sheet like this:
So how do we get this data into the template, create a PDF and send it via email? Going back to the VIP example, the helper would do the following steps manually:
So this is what we want to automate, as you don't need much brain to do that, once you know how it's done.
Google has a tool for that kind of automation: Google Script — it allows you to write Javascript with Google specific extensions to do more than the regular stuff in Google spreadsheet. To add a script to our sheet we go to
'Tools' and this time choose
'Script editor...' — the window that opens looks like this:
This is a new Google Script file with extension
.gs that is accessible in your spreadsheet. We need to replace the function with the one that we want to build:
sendFilledFormByEmail(). It might look like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
This is an ugly hack. But good enough for a proof of concept. Let's have a closer look at each part.
1 2 3 4 5 6 7
In this part, we're creating the local domain language for the objects we want to deal with: The spreadsheet, the whole range of sheets within the spreadsheet, the sheet that is currently active which at script-runtime is always the sheet with the form submission data, and the line of the latest form submission, which is the data we currently want to use for building the PDF. Here is the second section:
1 2
This is just an example for how to copy data to the right field. With
sheet.getRange(line, 3) we get the data in the third column of the latest form submission, and with
sheets[1].getRange("C5").setValue() we designate we want to enter it on the sheet with the template in the cell C5. There could also be more complexity added, like validations, algorithms, lookup-tables, etc. but for our example copying is sufficient.
The next step is to create a PDF with the filled in template:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
This is an adapted form of a script example from Amit Agarwal. It builds a URL for receiving the proper PDF file, authenticates as the script and then fetches the PDF with the proper authentication. The key is, to specify
sheets[1] where 1 is the id of the sheet with the template, so we don't have all the other sheets or even the other form responses in the PDF that we sent out via email.
1 2 3 4 5 6 7 8
Mostly taken from the same script example, we finally create the email to be sent out with proper attachment, subject, message and email-address. When the form is used within a company gmail account, the email-address can be obtained by activating automatic collection of the submitter by enabling that feature in the configuration of the Google Form. Otherwise, the form needs an extra field asking for the email address the PDF should be sent to. Alternatively, putting a static email address will result in this email always being sent to the same recipient. And then it is sent in the last line.
But wait, we forgot to clean up the template. That's why we need to do this somewhere after generating the PDF:
1 2
Essentially, we want to reset all the fields that we touched while filling out the template. If data was copied into an empty field,
.clearContent() for that field is enough.
So that's our script.
By now we have a template, a form, a response sheet and a script. But even though Google knows they are somewhat connected, not all of them are really connected. Submitting the form enters the data in the response sheet, but nothing else happens. What we want is, that whenever the form is submitted, the script should run once.
For this we need to look at the menu bar in our Script editor, go to
'Resources' and select
'Current project triggers...' — this will open a dialog like this:
We click to add one and we get:
We can translate our goal to this UI language like this:
In the 'notifications' section, we can also add an email address of a person to be notified about the script encountering some problem — either immediately or on a scheduled basis. So, let's save and submit the form once again.
There we go. Within seconds I get the email to the gmail account I was logged on while filling out the form, it has the subject and message from the script, and attached is the PDF file with the sheet of the filled out template.
Are we done yet? No. This is a proof of concept. It works in the most basic way it can work. This is the beginning, not the end of it. Now begins the time of evaluating all the assumptions, testing all the different environments, tweaking all the wordings, individualising for different use cases, hardening against multiple concurrent users, smartening up the script, making it reliable, extendable, reusable, secure, and most important of all: more user friendly.
But the first step is done:
As an employee of my company I can fill out my travel expenses form properly so I can get reimbursed for my business lunch.
Surely, we could have that in a much easier way by just asking somebody for help doing it manually. But then we would face the same problem again and again. And so would others. By attacking the root cause of the problem and putting automation on it where possible, we made the process simpler and faster and less error prone. It made this process both more effective and more efficient. The cost we have to pay is the construction time and the maintenance time. The gain can be calculated by estimating how many people do it how often and how much time does it cost every single time. So if it is worth doing this depends on the situation — just like in this xkcd:
via https://xkcd.com/399
In a perfect world, we would not face unindividualised templated print forms anymore at all. But we, as a society, are not quite there yet. Even if technology already would allow us to do much better than what we are doing right now. So let us put more patches on things that are not ideal and help each other to get more free time to tackle the root problems we have. And also let us learn how to 'hack' the world, so that technology and bureaucracy are serving us, and not the other way around. Because at the end of the day, all we want to have dealt with are the important questions of our time. And not the trivial annoying ones that no one will ever remember.]]>
This is the summary of our testing practice that we have at Blacklane GmbH by the end of 2015.
To make it well-scoped we only describe the stable parts of our testing infrastructure and do not include material that is work-in-progress or is under experiment so this post could have been postfixed with "part 1" because we know we are not there yet with complete automation of our process.
Here we cover the kinds of tests that we have and the corresponding infrastructure behind them. Terminology we use is quite arbitrary, we do not stand on it to death: when people say "unit tests", "integration tests" or "functional tests", they often mean completely different things or just imply that they are the same thing. One example how we could even raise against our own terminology is that actually functional testing is just a subset of integration testing and should not stand as separate group: they share the same infrastructure, additional separation brings complexity to maintenance etc (we will describe both groups below thoroughly).
Still somehow we tried to come up with the most commonly used terms and so far it worked well for us. We appreciate any feedback about better terms or practices so let this summary be a good occasion for this sort of discussion.
On meetups or interviews it is very often that we ask devs who claim to have TDD badge among their skills or one their CVs or LinkedIn profiles:
Do you write tests? What exactly do you (do you not) test? What kinds of tests do you have? How much of testing coverage do you have? Do you really do TDD?
It is unfortunate but here are the answers that we hear most often:
We don't write any tests, our development plan is too tough for that (with expression of deep sadness a face).
We write unit tests, we only test "business logic" (whatever it means).
We have tried using Calabash or Frank but it didn't really work for us because their tests are hard to write and maintain.
Some devs are able to pass "bla-bla" part of this question but when it comes to pairing on some test-driven task we often feel like Mickey Mouse Blood Tears Say Reactive One More Time.
To be honest we also were there: we didn't know what to test, how to test, we couldn't explain to our stakeholders the benefits of test automation for iOS, so that every time we pronounced words "test" or "tests" we made them suspicious about what we were doing.
We still cannot always test everything but somehow our iOS community is maturizing, we have great books/blogs to read about test automation and test-driven development (we'll list a few at the end) and the most important we now understand that as soon as you are able to write one single test for particular piece of functionality all the subsequent tests of the same kind can be written very fast because you already have version 1 of your tool set for this particular kind of testing or group of features and most likely you will be able improve it a lot so no fear we have anymore about trying to put under test something that we previously didn't test at all.
Also we didn't meet a single person from non-tech staff who would have been willing to protect or patronize test automation upfront - we needed 67 meetings to argue about that additional time to actually write the very first set of integration or functional tests and only after a while it became clear to everyone including non-technical guys that we started spending less and less time on "mouse-driven development" and improved quality of our product so that finally it contributed to the overall climate of our daily work: I can sleep when the wind blows.
These are the heuristics we find useful in our practice, we call "heuristics" everything that helps us to write better code given we keep them in mind:
NSLocalizedString behind Localization class and test it, if it is
[UIImage imageNamed:] put your image construction behind Image Factory class and test it, if it is custom
User-Agent or some build setting like
CFBundleVersion, again put them behind corresponding classes and put those classes under test.
All of the following is implicitly organized as a table so that every section follows the same structure: what makes particular testing activity specific, its infrastructure details, examples and some useful hacks:
What it includes:
Given the above restrictions for unit tests target it contains everything that whitebox- unit- testing usually implies, like:
What it does not include:
Helpful tips:
Integration testing is the intermediate group between unit testing and functional testing. It shares much of its approach with unit testing but here the accent on integration of our code with the rest of project is made: we test integration of our UIViewController classes with their xibs/storyboards, test localization keys, test the fact that invocation of buttonWasTapped: produces call to a delegate and so on.
What it includes:
What it does not include:
This kind of testing is best described by what we not include to this group: everything that goes to unit or functional tests.
Functional testing is rather recent group that we introduced: previously those tests were part of integration testing suite and we even continue to think about those tests as a subset of integration testing but still we now find it practically meaningful to differentiate them into a separate group. The rational behind having this separate group is our observation that integration testing actually consists of two different groups of tests: unit-testing of some code that involves integration with the rest of the system (non-code files) and testing of, let's call it this way, view controllers or groups of view controllers in isolation.
It was a pivotal point for us when we had the first test written and that test case had been testing specific view controller in isolation: we stopped doing mouse-driven and started doing keyboard-driven development in this important area of iOS development. The idea was very simple: if we have screen that is 67 user taps or other gestures away from initial screen why do we ever need to every time go to it manually or wait while Xcode 7 UI test will make those steps for us, we could have just put our controller on "empty stage" i.e.:
…and then given we would have all of its dependencies satisfied: stub models, network calls, reproduce original view hierarchy for our controller to be displayed correctly - we could exercise our assertions on that screen without a need to get to it via numerous actions like taps, fill-in-textfield etc that are normally required to get to that screen in real application (or acceptance test case).
Later we realized that this group of tests also was different from the first group i.e. unit-testing of integration in a sense that it often involved multiple view controllers or services to communicate to each other so that it had more of practical sense to organize them not according to their view controller class names but according to the use cases that those actors were to execute.
.bundle for
.json fixtures and Fixtures class in that bundle that encapsulates reading from them.
Helpful tips:
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3
tester has very useful lower-level method
waitForAccessibilityElement:view:withElementMatchingPredicate:tappable: which allows you match everything custom that you might need.
Example 1: Push Notifications
Test case: make sure that your app opens correct target screen when user jumps into your application from a push notification alert.
You put your real initial view controller on stage, call
application:didReceiveRemoteNotification:fetchCompletionHandler: on your AppDelegate and write KIF assertions to ensure that your app ends on expected target screen corresponding to push notification payload. Of course you can also test all alternative courses along the way.
Example 2: You need to implement feature: your specific screen must have certain behavior when server returns 503.
Test case:
(Even before the following steps it is better to implement functional test for your screen when it works green against all 200 responses)
Example 3: Working with legacy code
Test case: one of your screens which is 67 taps from initial screen and you need to verify that is contains different labels depending on the input it receives after tap #66.
For that screen you have full-blown functional-reactive-declarative-massive view controller with ReactiveCocoa in it and with view models with ReactiveCocoa in them without any test coverage, everything is magically dependency-injected and you don't have a clue how to test it. Here are steps how we do it:
-[UIApplication sharedApplication].rootViewController = ...
-[APIManager setAPIKey:] or something like that, or some view model might be missing: create a one and inject it before putting system-under-test on stage.
What it includes:
What it does not include:
Helpful tips:
The following works together with above hack to disable animations (see functional tests)
1 2 3 4 5
User agent is just a class that encapsulates user credentials and other for test agent. We have three agents in our test suite:
Xcode users, add "IDEBuildOperationMaxNumberOfConcurrentCompileTasks=
sysctl -n hw.ncpu" to your xcodebuild commands and enjoy.`
We didn't test Xcode itself thoroughly but looks like it builds concurrently under the hood, so only command-line builds can have this speedup.
"Omnis qui quaerit invenit", here we are just listing the reading which is the most outstanding for us.
It's implementation context is Java but still it is the best book we have read so far on testing. It can be especially useful if you want to improve your integration and functional test practices. This book is MUST to be read.
No comments, everyone must read this classics.
Update: Recently I have published my notes on this book: Notes on "Test-Driven Development by Example" by Kent Beck.
This is another MUST. If you are new to it follow Jon's recommendation on where to start first on his About page.
This is not strictly related to TDD but is more about good industrial OOP in general. While everyone is excited about functional/reactive/Swift/etc we are filling the gaps in our understanding of what good-old-OOP is (and is not).
Updated later: see also similar post Offline UI Testing on iOS With Stubs by @albertodebo.
We have covered enough for one post. Here are the topics that are left behind the scope:
Some of those topics are still work-in-progress or even undiscovered at all (like mutation testing) but we're going to come through all of that and probably publish part 2 of this post but that will be another story for new 2016 year.
Merry Christmas and Happy New Year!]]>

subset: commoncrawl


text:
Tommy Hilfiger's Tommy Now Rock Circus was in full swing at Camden's iconic Roundhouse to launch his Fall 2017 collection where Eugene Souleiman, Wella Professionals Global Creative Director and ghd Fashion Week Ambassador, created individual rock inspired looks for each of the models.
The show came to life through a backdrop of aerial acrobatics, which set the scene for the reveal of the latest collection from TommyXGigi - headlined by the ultimate Tommy Girl, Gigi Hadid and joined by siblings Bella and Anwar.
There was a real rock concert feel to the show this season and for me, I wanted to create a look that was dishevelled, diverse and imperfect. I created an anti-cosmetic approach to the hair – juxtaposition to the glamorous make-up look to allow the girls personalities to come through.
The feeling for me is still a Tommy Girl, just tougher and more urban. She's not text book pretty or perfectly groomed straight from the salon. She just naturally throws things together, has her own individual style – the kind of girl everyone wants to be. Totally effortless. - Eugene Souleiman
Get the look…
Eugene took a laid-back approach to getting the hair show-ready, using EIMI and ghd tools. Each look was individual and transported each model into the cool rock and roll Tommy world.
The vibe is very cool. I wanted the hair to have a loose, nonchalant look that was very youthful. The hair needed to look unwashed, a couple of days old from dancing away at your favourite gig. - Eugene Souleiman
To start, Eugene sprayed abundant amounts of Wella Professionals Elements Conditioning Leave in Spray at the roots. The ghd Curve Soft Curl Tong was used to create broken movement and disrupt the hair's texture.
For Georgina May Jagger, I twisted her hair into a low ponytail and sprayed with EIMI Perfect Setting before letting the hair loose and diffusing with ghd Air Hair-dryer to create a natural wave. We sprayed a fine mist of EIMI Sugar Lift to create separation and increase the movement. - Eugene Souleiman
For other girls, Eugene used the ghd Curve Soft Curl Tong to create broken movement and disrupt the hair's texture.
For this look, I wanted to craft a rock and roll feel to the hair. Voluminous hair was tamed by flattening the roots with a hair net blow-dried with the ghd Air Hair-dryer to create a clean centre parting. - Eugene Souleiman
EIMI Sugar Lift was used to tame the roots and on the ends of the hair to enhance the texture. A light mist of EIMI Perfect Setting was then applied to finish the look.


text:
Brian Gilkison wrote: >I see in rev. 1.78 of 'check' that Gerald has moved to lq-nsgmls in place >of nsgmls as the SGML parser. He's applied Liam's "HTTP Host header" patch to nsgmls; not the rest of Liam's changes. The only changes are the name and the fact that lq-nsgmls sends a HOst header when it goes out to fetch a DTD off the net. (i.e. It's not really "lq-nsgmls"; it's "nsgmls with Liam Quinn patches") >Does Liam (Liam, are you there?) plan on >making a Win32 binary available, similar to those for James Clark's SP >package? Are the changes negligible enough that I can copy nsgmls.exe to >lq-nsgmls.exe, or is lq-nsgmls's output sufficiently different that the >check script reflects those differences? Well, since this isn't actually lq-nsgmls, the friendly output from Liam's version isn't a problem. You can use plain vanilla nsgmls.exe just fine.Received on Wednesday, 28 February 2001 18:30:47 UTC
This archive was generated by hypermail 2.3.1 : Tuesday, 1 March 2016 14:17:29 UTC


text:
Tita Enterprises provides expert Consulting and Coaching on systems and procedures. Implementing, Organizing, Re-organizing, Right sizing, and Training is our aim while working in your project.
Project Development. Review specifications and requirements to insure a successful completion of the project
Reorganizations. Review present systems and procedures to make recommendations to enhance productivity and reduce cost of existing operations.
Implementations. Project management to implement new or existing project. Includes update reports
Maintenance. Tita Enterprises is ready to continue to maintain or enhance your system as required. You, the client will be served to make sure your business is productive and profitable.
Coaching. Training staff to become efficient in the implementation of the projects and to continue to operate efficiently
All of our services come with a 100% money back satisfaction guarantee.
Tita Enterprises


text:
|Karim Belabas on Fri, 06 Feb 2009 10:56:18 +0100
[Date Prev] [Date Next] [Thread Prev] [Thread Next] [Date Index] [Thread Index]
|Re: Programming with PARI in C++
* Justin Sweeney [2009-02-05 22:48]: > I am working on a project involving writing a program which uses PARI > functions. The program is written in C++. One of the functions I am > using is nextprime(x). I am having problems using this and other > functions in the C program. Essentially, the compiler is expecting the > variable 'x' in nextprime(x) to be a long int* and the function > apparently returns a long int*. Does anyone know anything about > passing variables to PARI functions in C, such as if they must be > this type or if that can be changed? Sorry, I don't understand the problem: as most PARI functions, nextprime indeed takes and returns a GEN, which is typedef'ed to long *. Can you post a specific (small) fragment of code that you believe should compile, but does not ? Just in case: if your problem is how to pass (and recover) an ordinary long int, use something like itos( nextprime(stoi(10)) ), which of course will overflow if the returned value is too large. If you use the pari-testing branch from our svn, i.e version 2.4.3 (development), you may directly use unextprime(). Cheers, K.B. -- Karim Belabas, IMB (UMR 5251) Tel: (+33) (0)5 40 00 26 17 Universite Bordeaux 1 Fax: (+33) (0)5 40 00 69 50 351, cours de la Liberation http://www.math.u-bordeaux.fr/~belabas/ F-33405 Talence (France) http://pari.math.u-bordeaux.fr/ [PARI/GP] `


text:
5B MTVNL 1050UTC data only
5C DR Deutschland 0500 - 0635 UTC 7-12dB SNR
6B Noord-Oost NL 0500 - 0635 UTC 7 dB SNR
7A Zuid NL 0500 UTC data only
8A Randstad NL 0635 - 1050 UTC 8-11 dB SNR
9D Nord-West NL 0500-0600 UTC 0-9dB SNR
10B Norfolk 0500-0600 UTC 11-16 dB
10C Northamptonshire 0500 - 0635 UTC 10-17dB
10C Suffolk 1050 UTC - data only
10D Herts-Berks 0635 UTC 10 dB SNR
12C NPO 0635-1050UTC -data only
12D Essex which is normally received was absent until the 1050UTC check when it was back at a normal 14-15dB - presumably messed up by interference from Europe
If find that an SNR ratio less than 5dB gives no audio, whilst 7dB gives full audio - on DAB+
THe only positive identification is Nord-West NL on 9D from Weiringerwerf as its the only site for this MUX/freq. Noord-Oost NL on 6B is likely Lelystad as that site was also received on FM in the same time period, but then so was Smilde!
Shame the Transmitter id function does not appear to be used.
DAB Log 28 Sept 2016
Post Reply
1 post • Page 1 of 1
DAB Log 28 Sept 2016
SDRPlay, AirSpyMini, RTL dongles, SB920s, Yamaha TX930. 5 ele compact yagi on rotator at 18ft agl. FM5 facing east, FM5 facing south, FM3 facing NE, OIRT dipole, 3-ele Moxon vertical facing east.
Post Reply
1 post • Page 1 of 1


text:
Mexico travel guide
Mexico travel guide – Tulum is really a really small city regarding an hour or so . 5 towards the south associated with Cancun upon Mexico's Carribbean shoreline. Actually the city (pueblo) is actually little sufficient that you should stroll close to as well as consume all of the incredible places. The actual highways listed here are really toned that makes it well suited for breakthrough the region through bicycle. Taxis listed here are inexpensive however, you should always make sure to concur a cost using the car owner before you decide to enter the automobile. Even though Tulum offers observed a few improvement recently this nevertheless continues to be the peaceful unspoilt city. Encircled through exotic new world the city includes a magnificent beach Resort Area. Tulum includes a great choice of dining places, pubs as well as stores.
Tulum hosts a few incredible nicely maintained Mayan damages that are typically the most popular visitor appeal in the region. Found on the slope looking over the ocean these types of historic damages had been found within the 1800's. Continue reading


text:
How did you and your mate spend the last weekend? Doing chores? Mowing the lawn? Rushing from the kids' soccer game to a fast-food restaurant to the next obligation? Or did you steal away for a little fun and romance? Smart couples realize that if you want a strong relationship, it's vital to schedule time together -- and weekends provide the perfect opportunity for romance. Stoke the flames with these weekend getaway strategies.
Plan Ahead
(Secret ingredient: Anticipation) Every three months, sit down with your mate and open your calendars. Identify at least one weekend per month that you'll reserve just for the two of you and schedule it -- no work, no cell phones, no intrusions. If you have kids, arrange for their care, perhaps by trading child care weekends with another couple. Schedule an entire quarter in one sitting.
Start a file of ideas for places to visit and things to do. Since a weekend doesn't allow much travel time, cruise the travel aisle of a bookstore or library and grab books about your area for ideas. Go online together (try the sites below) for more regional options.
Go on a Quest
(Secret ingredient: Discovery) Have a secret passion for caves, antiques, whales, good wine, rock and roll memorabilia? Go on a quest together. Psychology Today reports, "Couples who share exciting experiences report more relationship satisfaction, as well as more romance, than do couples with more mundane habits." Take a class to learn more about your obsession, and, if necessary, physically train for your quest in advance. Seeking and discovering together creates excitement, unity and a lot to talk about afterward.
Quirky Fun
(Secret ingredient: Laughter) Think beyond the obvious and try something fun and different. Cuddle in a sleeping bag for two under the night sky the second week of August and watch the Perseid meteor showers. Re-create the season you met, complete with food, fashions, music, and, if you have them, old love letters. Stay somewhere off-beat -- such as a weekend in a caboose, complete with hot tub and sumptuous breakfast, at the Featherbed Railroad Company (www.featherbedrailroad.com).
Stick to the Budget
(Secret ingredient: Sensory bliss)
If your budget limits travel or tickets, make your romantic getaway a stay-at-home vacation for the spirit and senses. Locate the best sunset in your area and watch the sun sink together as you savor wine and chocolates. Go to a private park, beach or mountaintop and absorb the beauty together with a specially created soundtrack of romantic songs (see below) for the occasion. Lounge on a luxurious blanket for a fireplace picnic and share a delectable treat or two. No fireplace? Turn out the lights and display a virtual "fire" or "aquarium" on your TV (www.fogware.com).
(Secret ingredient: Luxury) Celebrate special occasions -- not just your anniversary, but perhaps the first day of autumn, or to honor an achievement or to express gratitude for surviving a challenging time. For these weekends, go for broke with deluxe accommodations and indulgences. The fact that it's only for a weekend will help contain costs while providing memorable moments to cherish. Check out the romance packages at luxury hotels and resorts and splurge for upgraded rooms, champagne and strawberries, massages for two, front row tickets or a private gourmet dinner on your balcony.
But what about the weekends you can't get away? Do your chores. Volunteer. Go to the soccer game. Put the kids to bed. Then cuddle with your mate to relive the memories and dream about the next romantic getaway weekend.


text: Is it accurate to say that you are searching for stocks that are hinting at bottoming out? Here's a glance at probably the most whipped securities in the present market that might be prepared for a bounce back. Financial specialists can utilize this rundown to discover potential contender to purchase before the stocks start to […]Continue Reading


text:
Vielmansavu A (JS), 7-9 hengen huoneisto
semi-detached house, Levi, Kittilä, 7+2 persons
Quality class: Q3
Number of persons: 7 + 2
Area: Immel
Address: Purolantie 9, 99130 Sirkka
Distances: Centre: 2,3 km, Shop: 2,5 km, Nearest piste: 0,8 km, Skiing track: 0,2 km,
Snowmobile route: 0,5 km, Golf course: 6,3 km, Ski bus route: 0,3 km
Type: apartment from a log built semi-detached house
Built: 1999
Area: downstairs 69 m2 loft 30 m2
Bedrooms/other bed places: 2 bedrooms, upstairs a sleeping nook and open space
Beds: in one bedroom 2 single beds and in one bedroom double bed. In the sleeping nook 3 single beds.
In the open space a bed sofa. In the living room also a bed sofa.
Toilets: 2, of which 1 in lavatory
Sauna: electric sauna
Equipment: dishes, fireplace / firewood, cable-tv, radio-CD-player, VCR, DVD,
electric stove+oven, dishwasher, microwave oven, coffee maker, kettle, toaster, fridge, small freezer,
washing machine, electric clothes drying cupboard, iron, car heating points.
Other things to be mentioned:
No pets allowed! No smoking!
In the yard a smoke sauna which can agree with the care taker with price 290 E/warming.
If additional services- departure cleaning, bed linen and towels are not ordered with the accommodation
booking or arent already included in the price, please clean the apartment properly and bring your own bed linen and towels with you.
Basic information
| Kittilä
Show location on map
|Type of holiday home:
|semi-detached house
|Name of holiday home:
|Vielmansavu A (JS), 7-9 hengen huoneisto
|Living area:
|69 m²
|Number of bedrooms:
|Number of beds:
|Number of additional beds:
|electric sauna, indoor sauna
|Rental number:
|Pets allowed:
|not allowed
|Smoking allowed:
|not allowed
|Facilities and equipment:
|laundry machine
|Leisure-time activities:
|hunting, horseback riding, children activities, motor sledging, fishing, ice skating, picking mushrooms/berries, roller-skating, cross-country skiing, canoeing, tennis, golf, hiking, downhill skiing, biking
The destination is rented out by
99130 Sirkka
Tel. 016 639 3370


text:
|Click Here to Login
« Grand Duke Jean's 95th Birthday Celebrations: January 9, 2016 | State Visit from Romania to Luxembourg: June 6-7, 2016 »
Our communities encompass many different hobbies and interests, but each one is built on friendly, intelligent membership.
» More about our Communities
Our Marine websites focus on Cruising and Sailing Vessels, including forums and the largest cruising Wiki project on the web today.
» More about our Marine Communities


text:
Call for Papers: SACRPH 17th National Conference on Planning History
26th-29th October 2017 Cleveland, Ohio, USA
"The Society for American City and Regional Planning History (SACRPH) presents: THE 17TH NATIONAL CONFERENCE ON PLANNING HISTORY Cleveland, Ohio, October 26-29, 2017 SACRPH cordially invites scholars and practitioners to present papers and talks on all aspects of urban, regional, and community planning history and their relationship to urban and metropolitan studies.
Particularly welcome are papers, talks, roundtables, and sessions addressing the theme of Theory and Practice in Planning History. What is the relationship between the ideas shaping metropolitan development and the history of the built environment?
SACRPH is an interdisciplinary organization dedicated to promoting humanistic scholarship on the planning of metropolitan regions. SACRPH members include historians, practicing planners, geographers, environmentalists, architects, landscape designers, public policy makers, preservationists, community organizers, students, and scholars from across the world.
SACRPH publishes a quarterly journal, The Journal of Planning History, hosts a biennial conference, and sponsors awards for research and publication in the field of planning history.
The Program Committee welcomes proposals for complete sessions (of three or four papers) and for individual papers. We also encourage submissions that propose innovative formats and that engage questions of teaching and learning, digital information, and publishing.
Proposals must be submitted by February 25, 2017."
More details: website


text:
+27 (0) 11 886 8245
+27 (0) 11 886 8084
5th Floor Petrob House, 343 Surrey Avenue,
Ferndale, Johannesburg
Box 27, Private Bag X4006,
Ferndale , 2160 , South Africa
Toggle navigation
Membership Overview
Membership Fees
South African Registration
International Registration
Junior Membership
Non-Guiding Membership (Nature Enthusiast)
List of paid up members
How to get qualified
Field Guide Qualifications
Resource Library
FGASA Assessors
Log Books
Practical Assessment
Legal Advice
Job Market
Code of Conduct
CATHSSETA Certificates
Who can write a FGASA exam?
FGASA Exams
Exam Registration procedure
Venue Details
Endorsed Training Providers
Contact Us
CATHSSETA International members
CATHSSETA South African members
What it is
It is the provision of an array of legal services to members by a lawyer well versed in smme, travel & tourism matters
It is a legal service that is accessible to members (especially when urgent problems arise) 18 hours per day/7 days a week/365
It ensures legal compliance & peace of mind
Why it has been established
It gives members ready, easy access to a lawyer well versed in smme, travel & tourism matters almost 24 hours per day
Legal crises can be dealt with swiftly & effectively
Costly litigation can be avoided or dealt with more effectively
Customers can be kept happy & retained
Compliance with legal & statutory requirements is ensured
It means that legal issues within the industry will be dealt with in a consistent and on a pro-active basis
Standard template documents required by members will be prepared & made available at very reasonable prices
Training & updates on legal matters will be provided regularly & on a pro-active basis
It will result in a more professional industry
It frees members up to focus on their bottom line
Case law impacting on business will be implemented
How do you become a member?
Sign one of three contracts:
R4 800 a year ensures that you get one hour's legal advice per month for R400 (additional hours R900,00 per hour)
R2 400 a year ensures that you get half an hour's legal advice per month for R200 (additional hours R1 100,00 per hour)
You can purchase 3 (R1250/hour), 6 (R1150/hour) or 9 (R1000,00/hour) hours of legal advice to use if & when required
All legal problems will be dealt with by adv. Louis Nel who has 30 years' experience in the smme, travel & tourism industry.
It will ensure treatment of all legal problems i.e. whereas in the past legal problems or potential legal problems may have been 'swept under the carpet' due to inter alia cost considerations, these will now all be reported and dealt with swiftly and effectively.
Proper legal structures such as trading conditions, credit applications and effective methods to anticipate and deal with other legal issues will be implemented on a pro active basis.
Members often require urgent ad hoc legal advice when confronted by a legal problem especially when a customer is present or on the telephone.
Members will have access to adv. Louis Nel via his cellular telephone between the hours of 04:00 and 22:00 7/365.
The documentation used by members will be interpreted in a consistent manner.
All members will have quick and ready access to a lawyer who is not only familiar with the smme, travel & tourism industry, but also one who is part of the 'ASATA, SATSA, FGASA & SAACI families' and familiar with their 'workings'.
Adv. Louis Nel works closely with members of the ASATA, SATSA, FGASA & CMP boards on all legal matters, which means joint (and consistent) decision making and it ensures that the board at all times has its finger on all legal matters within their organisations.
It does not mean members must terminate their relationship with their current lawyer.
Access to mediation i.e. cost effective resolution of potential litigious issues.
Legal fees that is very competitive.
'in-house' training once a 'legal audit' has been carried out
Discounts for lac breakfasts & presentations.
Discounts for documentation specially prepared for the industry (e.g. booking forms, st&c, indemnity, credit application, credit card authorization form, loyalty contract, privacy policy, travel policy, travel management agreement.)
Updates on legal documentation purchased.
© 2019 Field Guides Association of Southern Africa. All rights reserved


text:
Real Estate in San Gabriel, CA
San Gabriel is located in California. San Gabriel, California has a population of 40,424. San Gabriel is less family-centric than the surrounding county with 32.99% of the households containing married families with children. The county average for households married with children is 33.62%.
The median household income in San Gabriel, California is $56,238. The median household income for the surrounding county is $55,870 compared to the national median of $53,482. The median age of people living in San Gabriel is 42 years.
San Gabriel Environment
The average high temperature in July is 85.5 degrees, with an average low temperature in January of 45.1 degrees. The average rainfall is approximately 20.3 inches per year, with 0 inches of snow per year.
San Gabriel Map
San Gabriel Real Estate offices
Sort by:
Real Living Properties Unlimited
Real Living Pacific Realty
Real Living Premier Realty
Real Living College Realty
Real Living Sugar Pine Realty
Real Estate near San Gabriel
Nearby Cities
San Gabriel Zip Codes
Nearby Cities Homes for Sale


text:
Candles are used in 7 out of 10 households in the United States. Us being one of those families. Not anymore though.
I have always LOVED the clean scent of candles and they way they our space smell. What I didn't realize is how harmful they can be to you.
We recently had an small office built for me to work out of. I am in there around 10 hours a week and naturally, this was my own private space. Away from the husband and kids where I could work in peace and quiet. Of course decorating it was something I was so excited to do and the few hours a night I would be in there, I would light a candle.
The space is small but definitely the size of a small to medium size bedroom.
A few days later I noticed this black design almost on my blinds and at first thought it was the pattern in the blinds. The days would pass and it was getting progressively worse. In addition to that I started noticing my fingers were black and my desk had black fingerprints on it. The candles were not from the dollar store and were from a very large retailer.
Let me also point out I have NOT been sick in close to 8 years and just 2 weeks ago when I started noticing this, I got very sick.
Long story short, we realized it was the candle I was burning that was producing this "black soot" all over my entire office.
Once I started wiping things down we realized it was on the walls, my desk, containers I was storing items in and even my door! Thankfully nothing was damaged but it took us close to 24 hours to wipe everything down. The image above was the water we were rinsing the sponge out with that we wiped the walls down with. This wasn't even the part that bothered me the most. It was the fact that I was breathing this in. The fact that when I have candles lit inside my home , my CHILDREN are breathing this in. 🙁
Thank God we noticed it after only a few days and it was only the walls and blinds that were soaking up the soot since this is where the candle was burning.
Regardless, I will not be using candles anymore and just wanted to share my experience. I know there are "safe" candles you can use , all natural SOY candles as well which is what I usually burn in my home. The bottom line is the fact that I am breathing this soot in and could be in my lungs is bothersome.
Below is a screenshot of the blinds and what they looked like after burning the candle for ONE night. They were new blinds that were just put up and 2 days later this is what they looked like. 🙁
I do love the scents these candles emit but my health is more important. I have looked into Scentsy and have a warmer from them I purchased last year that I will be breaking out again and also purchasing another one for my office now.
Since the wax is warmed and not burned as with traditional candles, no harmful chemicals or pollutants are released into the air. With Scentsy, there is no flame, smoke, soot or lead. Scentsy Bars do not contain or release harmful phthalates.
This will be what I will only be using now for the future. 🙂
If you have a friend that Sells Scentsy , I highly recommend grabbing a really cute burner from them and use this instead of candles.
If you do not know anyone , I went ahead and asked a member of my group that sells it to share her link for everyone.
Go HERE to see what Scentsy is all about and what they have to offer. You will have until December 9th to purchase through her link this way you can get your goodies before the holidays.


text:
In Memoriam – Dr. James H. Billington
The Fulbright Finland awardees to the United States for the next academic year will receive their grants at the Fulbright Finland Award Ceremony at the Helsinki City Hall on May 16. The event is hosted jointly by the Ministry for Foreign Affairs of Finland and the City of Helsinki. Altogether 38 scholars, teachers, students and professionals will be going to the United States on a Fulbright Finland grant next year to study, lecture, or for research or professional projects.
The Fulbright Finland Foundation and the University of Eastern Finland have been cost-sharing grants for Finnish students and researchers to visit and conduct research at universities in the United States already since 1987. The partners celebrated the 30th anniversary of their collaboration at the Saastamoinen Foundation in Helsinki on November 21.
Altogether 34 new Fulbright Finland scholars, teachers, students and professionals heading to the United States for the next academic year will receive their grants at the Fulbright Finland Award Ceremony at the Helsinki City Hall on May 17, 2017. The event is hosted jointly by the Ministry for Foreign Affairs of Finland and the City of Helsinki. In addition to the new Finnish awardees and the current American Fulbright grantees, the events honors the Centennial Year of the Republic of Finland.
Fulbright Center (the Finnish Fulbright Commission) has now officially been registered as a not-for-profit foundation in Finland. The Deed of the new Fulbright Finland Foundation was signed on May 13, 2016, by Jouni Mölsä, Director General of Communications of the Finnish Ministry for Foreign Affairs, and Susan Elbow, at the time Deputy Chief of Mission of the U.S. Embassy in Helsinki. The formal registration by the Finnish Patent and Registration Office went into effect on October 3, 2016.
Press Release
June 15, 2016
The Fulbright Center in Finland will host an international education conference in Helsinki in June under the title of Crossing Borders for Global Partnerships. The conference takes place at the Hilton Helsinki Kalastajatorppa on June 19-22.
University of Colorado Denver Architecture Program Partners with the Fulbright Center for Scholarships
The Fulbright Center Finland and University of Colorado Denver have signed an agreement enacting a new scholarship award. This new award targets Finnish students pursuing Masters in Architecture and awards recipients full tuition waiver for two academic years at CU Denver along with additional support services provided by the Fulbright Center.
CU Denver Director of Finnish Initiatives and Associate Professor Taisto Makela believes the program will bring positive change to the lives of its recipients and open international doors in the professional world.
Fulbright Center Press Release November 16, 2015
Hanken School of Economics has signed an agreement with the Fulbright Center establishing the Fulbright-Hanken Distinguished Chair in Business and Economics.
The agreement provides prominent American scholars the opportunity to lecture and conduct research at Hanken. During their stay, the scholars will also contribute to sharing Hanken's research and knowledge within the business community and society at large.
According to the 2014 Open Doors Report on International Educational Exchange, the number of American students enrolled in Finnish institutions of higher education in 2013/14 was 294, which is nearly 15 per cent higher than the year before (256). Looking at the reverse side of the student mobility picture, Open Doors also reported that 656 Finnish students studied in the U.S. in the 2013/14 academic year.
Starting tomorrow, on November 12, the Fulbright Center will recognize International Education Week, the annual worldwide celebration of the value of international education and exchange. First held in 2000, International Education Week is now celebrated in more than 100 countries worldwide.
The grantee must have a Ph.D. and be U.S. citizen. Applications will be accepted in all disciplines represented at University of Tampere. The grant is jointly funded by the Fulbright Center and University of Tampere.
The grant agreement was signed on Thursday 14 March by Fulbright Center's Executive Director Terhi Mölsä. University of Tampere is currently hosting the America in Living Color seminar, in which the current Fulbright grantees talk about their research in Finland.
Fulbright Bicentennial Professor Richard Schein will give his inaugural lecture on Tuesday, 27 November 2012, at 10:00 a.m. The topic of his lecture is Historical Geographies for the Present: stories of land and landscape.
The lecture will be held at the University of Helsinki main building, Small Hall. (Fabianinkatu 33, 4th floor). No registration needed.
+358 44 5535 286


text:
Lenovo, the world's largest personal computer maker, is ready to beef up its smartphone business with the aim of selling more than 100 million units globally in two years as soon as the US approves its acquisition of Google's Motorola Mobility.
Its goal is to gain hard on the heels of Samsung Electronics and Apple, the world's top smartphone makers, following its US$2.9 billion acquisition, which marks the fourth-biggest by a Chinese company.
This has enabled the Chinese PC maker to further boost its technological leverage and diversify into mobile as it will be able to use more than 2,000 lucrative patents held by Motorola Mobility, analysts and industry sources said.
Lenovo chairman and CEO Yuanqing Yang said in an interview with the media that it would be able to achieve its sales target and compete alongside Samsung and Apple through the deal, as the Chinese PC maker has a strong foothold in China and emerging markets. Motorola Mobility, on the other hand, has a strong presence in North America and Latin America.
Currently, the global shares held by Lenovo and Motorola in the smartphone market may look minuscule, with Lenovo holding about 4 per cent market share while Motorola has little more than 1 per cent.
But when the two combine forces and use each other's strengths, particularly in engineering and innovation, the Lenovo chairman said both sides would see a "complementary and perfect" synergy.
The partnership will enable the two companies to use their diverse marketing and distribution channels across the world to introduce "Motorola by Lenovo" smartphones, and take on and hopefully beat Samsung and Apple in the near future, the chairman added.
Samsung Electronics spokespeople were unavailable for comments on the partnership.
Samsung had dominated 2013 with more than a 30 per cent share in the global smartphone market, followed by Apple's 15 per cent, according to data from research firm IDC.
Lenovo, the second-largest Chinese smartphone brand, had sought to boost its smartphone capability amid the rise of mobile and the fall of PCs. PCs account for about 80 per cent of its annual sales.
Lenovo turned to Google to seek acquisition of Motorola Mobility after its failed attempt to buy BlackBerry, which the Canadian government refused as the company was deemed important to its economy.
Lenovo and Google competed to buy Motorola Mobility and its long list of attractive patents in 2011. Google won the deal spearheaded by co-founder and CEO Larry Page as Apple increased its warfare against Google's Android, which late-CEO Steve Jobs branded as a "rip-off" of Apple's iOS.
Google decided to liquidate Mobility as its smartphone hardware was unable to bear fruit unlike its mobile operating system used mostly by its partners including Samsung, which also faces legal feud with Apple over designs and key functions of their smartphones.
Analysts had given a positive outlook for Lenovo in overseas markets even before its landmark purchase of Mobility.
"We see a good chance of Lenovo penetrating into other emerging countries with its smartphone product, such as Indonesia, India, Russia and Vietnam," BNP Paribas said in a report last November.


text:
Some people like you, some people don't. In the end you just have to be yourself.
There are moments when the human body can overcome things you would never expect.
Small players learn to be intuitive, to anticipate, to protect the ball. A guy who weighs 90 kilos doesn't move like one who weighs 60. In the playground I always played against much bigger kids and I always wanted the ball. Without it, I feel lost.
I get the feeling people respect me and that there is affection for me. That makes me happy.
If you win without sacrifice you enjoy it but it's more satisfying when you have struggled.
If there is one thing that all players have in common it is that winning, competitive gene; the ability to overcome obstacles and fight for what you want from your career.
In the past, I had my idols but today I enjoy learning from all the soccer I watch.
Perfection doesn't exist.
I don't consider myself a star.
I like to watch soccer, no matter what teams or players are in the field.
There is no rule that says a footballer needs to be 'this high' and 'this wide.'
Every player wants to be as complete as possible and goals for a central midfielder are very important.
What I do when speaking in public is trying to do it as best as possible and trying to make everybody comfortable with my words. Sometimes getting this is very difficult, but I try my best.
La Masia is a place where lots of people live together but you are on your own.
My father has made a museum with my cuttings and photographs.
For un-subscribe please check the mail footer.


text:
From the Editor: Legislative session's over, but The Herald's vigilance isn't
More than 1,800 bills were filed during this year's state legislative session, ranging from teacher pay raises to the contentious debate over Medicaid expansion.
The enormous task of tracking those key issues and hundreds more falls to our tenacious Tallahassee staff, whose marathon coverage of the 60-day session reached its crescendo last week. Our strength lies in the combined forces of The Miami Herald's and Tampa Bay Times' Tallahassee bureau, the largest in the state.
"It's a humongous state with huge issues," said Mary Ellen Klas, The Herald's bureau chief. "We are the watchdogs."
It is a tall order as legislators and lobbyists jockey for position in the final frenzied stretch of the session, rewriting bills and tacking on amendments during the waning, caffeine-fueled hours of the session.
"Things get very hectic, especially at the end," said Politics Editor Sergio Bustos. "They have a deadline and they have to get things done."
Our reporting dexterity can make a big difference on key issues that have lasting impact here at home.
Kathleen McGrory tracked important educational issues, from a sweeping education bill to revamp the state's high school graduation requirements to the controversial parent trigger bill, legislation aimed at giving parents a voice in charting a turnaround plan for failing public schools. When a mysterious video appeared in the capitol, showcasing South Florida moms praising the bill, McGrory's reporting revealed that the video was produced by a California-based advocacy group and not a local grass-roots movement. Three days later, the parent trigger bill died in the Senate.
Toluse Olorunnipa kept close watch on a property insurance reform bill which, he reported, would have implemented double-digit rate increases for tens of thousands of new Citizens Property Insurance customers. After an outcry from homeowners, the bill was modified and stripped of the rate increase.
When a state and federal strike force arrested dozens of Internet gambling café owners who pocketed millions of dollars intended for veterans' charities, Klas reported that the Internet café industry had made more than $1.4 million in campaign contributions to Florida legislators and congressional members over three years. Legislators scrambled to return the money — and approved a bill outlawing the electronic gaming machines.
These were just a few of the key high-impact issues during this session, which also included a sweeping education bill to revamp the state's high school graduation requirements; campaign finance and ethics reform to make campaign contributions more transparent; the Miami Dolphins' bid to get public dollars for a stadium makeover; and a bill to end permanent alimony that was passed by the Legislature but vetoed by Gov. Rick Scott.
Though the formal session has ended, there is more work to be done as our team examines what lawmakers and lobbyists slipped into law in the final crush of legislation. That's always an eye-opener, and we'll be there to report it.


text: 5 Dec 2016 CHRISTMAS SHOPPING SPREE by bobeditor | posted in: Homepage News | 0 The BPS Annual Shopping Spree will be this Friday (December 9) Students will have the opportunity to shop for family and put some presents under the tree at home. Just a reminder that donations are still accepted until Thursday. Thank you for your continued support!


text:
a monthly sale on all things collectible!
Once a month Cyber City Comix offers its customers the opportunity to survey the vast sea of comic goodness that is its overstock warehouse. As if the deals couldn't get any better! Dollar comics, discount toys, cards, and statues guaranteed to make the frugal consumer drool with delight. Because we love you all very much.
855 Alness St #20, North York, Toronto, Ontario M3J 2X3.
2 Lights south of Dufferin and Steeles.


text:
Chandigarh (Face2News)
The new industrial policy announced by the Captain Amarinder Singh government in Punjab has triggered a wave of interest from investors, with Gurgaon-based Varun Beverages proposing a Rs. 500 crore investment to set up a drinks and water table unit in Pathankot.
The Group has sought an anchor unit status in the extreme border zone border zone with added advantage of an early bird unit for its proposed unit for aerated soft drinks, juice based drinks and table water at the PSIEC developed industrial estate in Pathankot.
The unit will provide direct employment to 350 people and indirect employment to another 1500 in three phases, the Group has said in its detailed proposal submitted to Suresh Kumar, Chief Principal Secretary to Chief Minister. Suresh Kumar has submitted the proposal to the Chief Minister's Office (CMO) for necessary action, an official spokesperson said here on Tuesday.
Varun Beverages CEO Rajiv Sant, while seeking the state government's support for grant of anchor status in extreme border area, with attached benefits, said the project was the first of its scale and kind in PSIEC. It will not only generate a huge employment potential but also act as a catalyst to attract other investments in the extreme border zone, located about 27 km from the International Border, he said. The project, he said, was a fit case for being deemed as an early bird unit, as per the "New Industrial and Business Development Policy-2017" for units in the extreme border zone. This would make the Company eligible for incentives @ 140% of the highest in that category (100% SGST refund up to 125% of FCI) to enable the group to start the construction immediately in time for their next season in 2019.
In the proposal, the Company said most of the raw material would be sourced locally, giving a boost to local manufacturers/growers of sugar, citrus fruits, service providers, packaging material and finished product suppliers. Further, the project was committed to providing 10,000 chilling equipments/machines to eligible candidates to facilitate setting up new outlets in the state to eventually provide livelihood to over 10,000 families.
In addition, the project, with its huge transportation and logistics requirement, would also justify the formation of a transport hub by local and national carriers. Further, it would impart training at a proposed skill development centre at its Pathankot plant to make 500-750 people employable every year for its Pizza Hut/KFC/Costa Coffee outlets across the country. Scores others would become skilled to gain employment outside the company.
The project would also be instrumental in developing various ancillary industries such as printing, packaging, corrugation, recycled bottles and hospitality. The state would start earning in full GST and other taxes as applicable once the period or value of FCI (as dictated by the policy) are covered, according to the proposal.