Зеленый хостинг ТЭИА


LTCBTC - Bitfinex



Syndicate content My RSS Feed
My RSS Feed
Updated: 51 weeks 6 days ago

Some of Intel's Effort to Repair Spectre in Future CPUs

Wed, 07/25/2018 - 16:48
by Zack Brown

Dave Hansen from Intel posted a patch and said, "Intel is considering adding a new bit to the IA32_ARCH_CAPABILITIES MSR (Model-Specific Register) to tell when RSB (Return Stack Buffer) underflow might be happening. Feedback on this would be greatly appreciated before the specification is finalized." He explained that RSB:

...is a microarchitectural structure that attempts to help predict the branch target of RET instructions. It is implemented as a stack that is pushed on CALL and popped on RET. Being a stack, it can become empty. On some processors, an empty condition leads to use of the other indirect branch predictors which have been targeted by Spectre variant 2 (branch target injection) exploits.

The new MSR bit, Dave explained, would tell the CPU not to rely on data from the RSB if the RSB was already empty.

Linus Torvalds replied:

Yes, please. It would be lovely to not have any "this model" kind of checks.

Of course, your patch still doesn't allow for "we claim to be skylake for various other independent reasons, but the RSB issue is fixed".

So it might actually be even better with _two_ bits: "explicitly needs RSB stuffing" and "explicitly fixed and does _not_ need RSB stuffing".

And then if neither bit it set, we fall back to the implicit "we know Skylake needs it".

If both bits are set, we just go with a "CPU is batshit schitzo" message, and assume it needs RSB stuffing just because it's obviously broken.

On second thought, however, Linus withdrew his initial criticism of Dave's patch, regarding claiming to be skylake for nonRSB reasons. In a subsequent email Linus said, "maybe nobody ever has a reason to do that, though?" He went on to say:

Virtualization people may simply want the user to specify the model, but then make the Spectre decisions be based on actual hardware capabilities (whether those are "current" or "some minimum base"). Two bits allow that. One bit means "if you claim you're running skylake, we'll always have to stuff, whether you _really_ are or not".

Arjan van de Ven agreed it was extremely unlikely that anyone would claim to be skylake unless it was to take advantage of the RSB issue.

That was it for the discussion, but it's very cool that Intel is consulting with the kernel people about these sorts of hardware decisions. It's an indication of good transparency and an attempt to avoid the fallout of making a bad technical decision that would incur further ire from the kernel developers.

Note: if you're mentioned above and want to post a response above the comment section, send a message with your response text to ljeditor@linuxjournal.com.

Go to Full Article
Categories: World News

The “fearless entrepreneur” is a myth: why you don’t have to take risks to build a successful business

Wed, 07/25/2018 - 16:48

When I was a kid, I worked in my cousin’s gift store.

I was so bored during those long, hot summers that I didn’t even ask him to pay me.

But one day I had a brilliant idea. I would go into the hills, pick figs from local gardens, and sell them to tourists.

I shared this plan with my cousin.

Categories: World News

can't load js in drupal 8 using hook_page_attachments

Wed, 07/25/2018 - 16:47

Here my module file I did exactly what the documentation https://www.drupal.org/docs/8/creating-custom-modules/adding-stylesheets-css-and-javascript-js-to-a-drupal-8-module say for declaring js files of a module and attaching the created library. But always can't see my module js file within the page code source. Here is my files content:
my_module.librarises.yml :

my_module.lib: version: VERSION js: js/my-module.js: {} dependencies: - core/jquery - core/drupalSettings - core/drupal


/** * Implements hook_page_attachments(). */ function my_module_page_attachments(array &$page) { $page['#attached']['library'][] = 'my_module/my_module.lib'; }

my-module.js (in my_module/js directory):

(function ($, Drupal) { $(document).ready(function() { console.log('Loaded...'); }); })(jQuery, Drupal);

In code source I can see "my_module/my_module.lib":

{"path": ..., {"libraries":.., "my_module/my_module.lib",..

But can't get the file js.

Categories: World News

How to access the existing field value in a custom field?

Wed, 07/25/2018 - 16:47

I have a content type which shows video in iframe from youtube. There is a field which I can enter the youtube link and it will render the iframe using the link.

I have created a custom field which will take the youtube link as input and get the youtube statistics using youtube api. The field will display a div in the page with view count and number of likes of the video.

I wanted to access the already existing field value (youtube link which shows iframe), to show my stats information, as both are same. In my custom field module, I am taking an input field which is the youtube url.

For a user, it will be repetitive, if he types the url twice. Also I already have so many contents added to my content types, so it will be a burden to the content creators to go and add values to my newly created field.

Is there any way, I can access the existing fields value of my same content type ?

Here is my code :


<?php namespace Drupal\youtube_stat\Plugin\Field\FieldType; use Drupal\Core\Field\FieldItemBase; use Drupal\Core\TypedData\DataDefinition; use Drupal\Core\Field\FieldStorageDefinitionInterface as StorageDefinition; /** * Plugin implementation of the 'player_info' field type. * * @FieldType( * id = "Youtube_stat", * label = @Translation("Youtube statistics"), * description = @Translation("To Display Youtube statistics"), * category = @Translation("Custom"), * default_widget = "Youtube_statDefaultWidget", * default_formatter = "Youtube_statDefaultFormatter" * ) */ class Youtube_stat extends FieldItemBase { /** * Field type properties definition. * * Inside this method we defines all the fields (properties) that our * custom field type will have. * * Here there is a list of allowed property types: https://goo.gl/sIBBgO */ public static function propertyDefinitions(StorageDefinition $storage) { $properties = []; $properties['videoId'] = DataDefinition::create('string') ->setLabel(t('Video Id')); return $properties; } /** * Field type schema definition. * * Inside this method we defines the database schema used to store data for * our field type. * * Here there is a list of allowed column types: https://goo.gl/YY3G7s */ public static function schema(StorageDefinition $storage) { $columns = []; $columns['videoId'] = [ 'type' => 'char', 'length' => 255, ]; return [ 'columns' => $columns, 'indexes' => [], ]; } /** * Define when the field type is empty. * * This method is important and used internally by Drupal. Take a moment * to define when the field fype must be considered empty. */ public function isEmpty() { $isEmpty = empty($this->get('videoId')->getValue()); return $isEmpty; } }


<?php namespace Drupal\youtube_stat\Plugin\Field\FieldFormatter; use Drupal\Core\Field\FieldItemListInterface; use Drupal\Core\Field\FormatterBase; use Drupal; /** * Plugin implementation of the 'Youtube_statDefaultFormatter' formatter. * * @FieldFormatter( * id = "Youtube_statDefaultFormatter", * label = @Translation("Youtube statisctics"), * field_types = { * "Youtube_stat" * } * ) */ class Youtube_statDefaultFormatter extends FormatterBase { /** * Define how the field type is showed. * * Inside this method we can customize how the field is displayed inside * pages. */ public function viewElements(FieldItemListInterface $items, $langcode) { \Drupal::service('page_cache_kill_switch')->trigger(); //$memory = (string)ini_get("memory_limit"); //ini_set('memory_limit', '-1'); $elements = []; foreach ($items as $delta => $item) { $JSON = file_get_contents("https://www.googleapis.com/youtube/v3/videos?key=*_API_KEY_*&part=statistics&id={$item->videoId}"); $JSON_Data = json_decode($JSON); $viewCount = $JSON_Data->items[0]->statistics->viewCount; $likeCount = $JSON_Data->items[0]->statistics->likeCount; //$dump_data = '<pre>'.json_encode($item).'<pre>'; $stat_div = "<div><span>Views : ".$viewCount."</span>&nbsp;<span>Likes : ".$likeCount."</span></div>"; //$result = $query->fetchAll(); $elements[$delta] = [ '#type' => 'markup', '#markup' => $stat_div, '#cache' => ['max-age' => 0] ]; } //ini_set('memory_limit', $memory); return $elements; } }

Is there any way to achieve this ?

Categories: World News

Attached node field appears in views field section but not as sort option

Wed, 07/25/2018 - 16:47

I've got a content type which has a like_count field, this field is integer type, I recently has added this field to my content type,

I edited the "My contents" view and added that field to my view, it was in fields list.

The problem is that when I wanted to add a sort option based on this field, I realized that this field is not listed in the sort options list,

I used to disable view caching based on an answer here but no luck.

any idea what the problem can be?

Categories: World News

Change node title with Rules

Wed, 07/25/2018 - 16:47

I have a content type 'supertest' with fields 'Category' and 'Section' (both are taxonomy terms reference, dropdowns). And every user has a 'Display name' custom field.

And I need to update title of nodes (of this content type) on every node save, desired format is '[category] - [section]: [author.display_name]'.

I've tried to add a rule (in Rules module) - actions 'Display message' (just to test) on 'Before content save', but it doesn't work. And I can't figure out how to set category field value to title.

How can I make rules to change title of a node in my drupal 8 site?

Categories: World News

How to pass dynamic variable to order by in views query alter?

Wed, 07/25/2018 - 16:47

I want to pass $a to $query->addOrderBy(NULL, 'node__field_tags.field_tags_target_id', 'ASC', 'node__field_tags.field_tags_target_id'); as field_tags_target_id.

Below is my views query alter function:

Can anyone to help me?

function custom_views_query_alter(ViewExecutable $view, QueryPluginBase $query) { // node ID instead of node title. if($view->id() == 'article_list'){ $user = \Drupal\user\Entity\User::load(\Drupal::currentUser()->id()); $art = $user->get('field_category')->getValue(); $a = $art[0]['target_id']; $query->addOrderBy(NULL, 'node__field_tags.field_tags_target_id', 'ASC', 'node__field_tags.field_tags_target_id'); dump($query); } }
Categories: World News

How to save/update cart programmatically?

Wed, 07/25/2018 - 16:47

as i am new to Drupal 8 can anyone help me out to add new product to cart in drupal 8 programatically? I have seen post Add product to cart programmatically for drupal 7

but i want same answer for drupal 8. Any help will be appreciated.

Categories: World News

JSON API how to filter by path alias or url?

Wed, 07/25/2018 - 16:47

We have a route like http://domain.com/jsonapi/node/article

Sample Json format looks like

{ "data":[ { "type":"node--article", "id":"f8bda885-776f-4f64-84b9-1bfec7462e10", "attributes":{ "nid":46, "title":"This is a test article", "path":{ "alias":"/46-test-article", "pid":196, "langcode":"en" } } } ] }

How to filter JSON data by path alias?

For instance, to filter JSON data where title equal to 'test' we have


Categories: World News

Underscore is added to links in view

Wed, 07/25/2018 - 16:47

I'm writing a workaround to fix the breaking changes introduced to our XML feed when we updated from Drupal 8.4 to 8.5. Since PATH is no longer available but has been replaced with LINK, I've had to craft the Rewrite Results to be /news/{{ view_node }}, which displays a properly formatted URL in the preview:


However, in the actual XML feed, it comes out like this:


arbitrarily adding an underscore and breaking the URL. Is there a way to make this not happen?

Categories: World News

How To Improve Test Coverage For Your Android App Using Mockito And Espresso

Wed, 07/25/2018 - 16:00
How To Improve Test Coverage For Your Android App Using Mockito And Espresso How To Improve Test Coverage For Your Android App Using Mockito And Espresso Vivek Maskara 2018-07-25T14:00:04+02:00 2018-07-25T12:06:31+00:00

In app development, a variety of use cases and interactions come up as one iterates the code. The app might need to fetch data from a server, interact with the device’s sensors, access local storage or render complex user interfaces.

The important thing to consider while writing tests is the units of responsibility that emerge as you design the new feature. The unit test should cover all possible interactions with the unit, including standard interactions and exceptional scenarios.

In this article, we will cover the fundamentals of testing and frameworks such as Mockito and Espresso, which developers can use to write unit tests. I will also briefly discuss how to write testable code. I’ll also explain how to get started with local and instrumented tests in Android.

Recommended reading: How To Set Up An Automated Testing System Using Android Phones (A Case Study)

Fundamentals Of Testing

A typical unit test contains three phases.

  1. First, the unit test initializes a small piece of an application it wants to test.
  2. Then, it applies some stimulus to the system under test, usually by calling a method on it.
  3. Finally, it observes the resulting behavior.

If the observed behavior is consistent with the expectations, the unit test passes; otherwise, it fails, indicating that there is a problem somewhere in the system under test. These three unit test phases are also known as arrange, act and assert, or simply AAA. The app should ideally include three categories of tests: small, medium and large.

  • Small tests comprise unit tests that mock every major component and run quickly in isolation.
  • Medium tests are integration tests that integrate several components and run on emulators or real devices.
  • Large tests are integration and UI tests that run by completing a UI workflow and ensure that the key end-user tasks work as expected.

Note: An instrumentation test is a type of integration test. These are tests that run on an Android device or emulator. These tests have access to instrumentation information, such as the context of the app under test. Use this approach to run unit tests that have Android dependencies that mock objects cannot easily satisfy.

Nope, we can't do any magic tricks, but we have articles, books and webinars featuring techniques we all can use to improve our work. Smashing Members get a seasoned selection of magic front-end tricks — e.g. live designing sessions and perf audits, too. Just sayin'! ;-)

Explore Smashing Wizardry →

Writing small tests allows you to address failures quickly, but it’s difficult to gain confidence that a passing test will allow your app to work. It’s important to have tests from all categories in the app, although the proportion of each category can vary from app to app. A good unit test should be easy to write, readable, reliable and fast.

Here’s a brief introduction to Mockito and Espresso, which make testing Android apps easier.


There are various mocking frameworks, but the most popular of them all is Mockito:

Mockito is a mocking framework that tastes really good. It lets you write beautiful tests with a clean & simple API. Mockito doesn’t give you hangover because the tests are very readable and they produce clean verification errors.

Its fluent API separates pre-test preparation from post-test validation. Should the test fail, Mockito makes it clear to see where our expectations differ from reality! The library has everything you need to write complete tests.


Espresso helps you write concise, beautiful and reliable Android UI tests.

The code snippet below shows an example of an Espresso test. We will take up the same example later in this tutorial when we talk in detail about instrumentation tests.

@Test public void setUserName() { onView(withId(R.id.name_field)).perform(typeText("Vivek Maskara")); onView(withId(R.id.set_user_name)).perform(click()); onView(withText("Hello Vivek Maskara!")).check(matches(isDisplayed())); }

Espresso tests state expectations, interactions and assertions clearly, without the distraction of boilerplate content, custom infrastructure or messy implementation details getting in the way. Whenever your test invokes onView(), Espresso waits to perform the corresponding UI action or assertion until the synchronization conditions are met, meaning:

  • the message queue is empty,
  • no instances of AsyncTask are currently executing a task,
  • the idling resources are idle.

These checks ensure that the test results are reliable.

Writing Testable Code

Unit testing Android apps is difficult and sometimes impossible. A good design, and only a good design, can make unit testing easier. Here are some of the concepts that are important for writing testable code.

Avoid Mixing Object Graph Construction With Application Logic

In a test, you want to instantiate the class under test and apply some stimulus to the class and assert that the expected behavior was observed. Make sure that the class under test doesn’t instantiate other objects and that those objects do not instantiate more objects and so on. In order to have a testable code base, your application should have two kinds of classes:

  • The factories, which are full of the “new” operators and which are responsible for building the object graph of your application;
  • The application logic classes, which are devoid of the “new” operator and which are responsible for doing the work.
Constructors Should Not Do Any Work

The most common operation you will do in tests is the instantiation of object graphs. So, make it easy on yourself, and make the constructors do no work other than assigning all of the dependencies into the fields. Doing work in the constructor not only will affect the direct tests of the class, but will also affect related tests that try to instantiate your class indirectly.

Avoid Static Methods Wherever Possible

The key to testing is the presence of places where you can divert the normal execution flow. Seams are needed so that you can isolate the unit of test. If you build an application with nothing but static methods, you will have a procedural application. How much a static method will hurt from a testing point of view depends on where it is in your application call graph. A leaf method such as Math.abs() is not a problem because the execution call graph ends there. But if you pick a method in a core of your application logic, then everything behind the method will become hard to test, because there is no way to insert test doubles

Avoid Mixing Of Concerns

A class should be responsible for dealing with just one entity. Inside a class, a method should be responsible for doing just one thing. For example, BusinessService should be responsible just for talking to a Business and not BusinessReceipts. Moreover, a method in BusinessService could be getBusinessProfile, but a method such as createAndGetBusinessProfile would not be ideal for testing. SOLID design principles must be followed for good design:

  • S: single-responsibility principle;
  • O: open-closed principle;
  • L: Liskov substitution principle;
  • I: interface segregation principle;
  • D: dependency inversion principle.

In the next few sections, we will be using examples from a really simple application that I built for this tutorial. The app has an EditText that takes a user name as input and displays the name in a TextView upon the click of a button. Feel free to take the complete source code for the project from GitHub. Here’s a screenshot of the app:

Large preview Writing Local Unit Tests

Unit tests can be run locally on your development machine without a device or an emulator. This testing approach is efficient because it avoids the overhead of having to load the target app and unit test code onto a physical device or emulator every time your test is run. In addition to Mockito, you will also need to configure the testing dependencies for your project to use the standard APIs provided by the JUnit 4 framework.

Setting Up The Development Environment

Start by adding a dependency on JUnit4 in your project. The dependency is of the type testImplementation, which means that the dependencies are only required to compile the test source of the project.

testImplementation 'junit:junit:4.12'

We will also need the Mockito library to make interaction with Android dependencies easier.

testImplementation "org.mockito:mockito-core:$MOCKITO_VERSION"

Make sure to sync the project after adding the dependency. Android Studio should have created the folder structure for unit tests by default. If not, make sure the following directory structure exists:

<Project Dir>/app/src/test/java/com/maskaravivek/testingExamples Creating Your First Unit Test

Suppose you want to test the displayUserName function in the UserService. For the sake of simplicity, the function simply formats the input and returns it back. In a real-world application, it could make a network call to fetch the user profile and return the user’s name.

@Singleton class UserService @Inject constructor(private var context: Context) { fun displayUserName(name: String): String { val userNameFormat = context.getString(R.string.display_user_name) return String.format(Locale.ENGLISH, userNameFormat, name) } }

We will start by creating a UserServiceTest class in our test directory. The UserService class uses Context, which needs to be mocked for the purpose of testing. Mockito provides a @Mock notation for mocking objects, which can be used as follows:

@Mock internal var context: Context? = null

Similarly, you’ll need to mock all dependencies required to construct the instance of the UserService class. Before your test, you’ll need to initialize these mocks and inject them into the UserService class.

  • @InjectMock creates an instance of the class and injects the mocks that are marked with the annotations @Mock into it.
  • MockitoAnnotations.initMocks(this); initializes those fields annotated with Mockito annotations.

Here’s how it can be done:

class UserServiceTest { @Mock internal var context: Context? = null @InjectMocks internal var userService: UserService? = null @Before fun setup() { MockitoAnnotations.initMocks(this) } }

Now you are done setting up your test class. Let’s add a test to this class that verifies the functionality of the displayUserName function. Here’s what the test looks like:

@Test fun displayUserName() { doReturn("Hello %s!").`when`(context)!!.getString(any(Int::class.java)) val displayUserName = userService!!.displayUserName("Test") assertEquals(displayUserName, "Hello Test!") }

The test uses a doReturn().when() statement to provide a response when a context.getString() is invoked. For any input integer, it will return the same result, "Hello %s!". We could have been more specific by making it return this response only for a particular string resource ID, but for the sake of simplicity, we are returning the same response to any input. Finally, here’s what the test class looks like:

class UserServiceTest { @Mock internal var context: Context? = null @InjectMocks internal var userService: UserService? = null @Before fun setup() { MockitoAnnotations.initMocks(this) } @Test fun displayUserName() { doReturn("Hello %s!").`when`(context)!!.getString(any(Int::class.java)) val displayUserName = userService!!.displayUserName("Test") assertEquals(displayUserName, "Hello Test!") } } Running Your Unit Tests

In order to run the unit tests, you need to make sure that Gradle is synchronized. In order to run a test, click on the green play icon in the IDE.

making sure that Gradle is synchronized

When the unit tests are run, successfully or otherwise, you should see this in the “Run” menu at the bottom of the screen:

Large preview

You are done with your first unit test!

Writing Instrumentation Tests

Instrumentation tests are most suited for checking values of UI components when an activity is run. For instance, in the example above, we want to make sure that the TextView shows the correct user name after the Button is clicked. They run on physical devices and emulators and can take advantage of the Android framework APIs and supporting APIs, such as the Android Testing Support Library. We’ll use Espresso to take actions on the main thread, such as button clicks and text changes.

Setting Up The Development Environment

Add a dependency on Espresso:

androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'

Instrumentation tests are created in an androidTest folder.

<Project Dir>/app/src/androidTest/java/com/maskaravivek/testingExamples

If you want to test a simple activity, create your test class in the same package as your activity.

Creating Your First Instrumentation Test

Let’s start by creating a simple activity that takes a name as input and, on the click of a button, displays the user name. The code for the activity above is quite simple:

class MainActivity : AppCompatActivity() { var button: Button? = null var userNameField: EditText? = null var displayUserName: TextView? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) AndroidInjection.inject(this) setContentView(R.layout.activity_main) initViews() } private fun initViews() { button = this.findViewById(R.id.set_user_name) userNameField = this.findViewById(R.id.name_field) displayUserName = this.findViewById(R.id.display_user_name) this.button!!.setOnClickListener({ displayUserName!!.text = "Hello ${userNameField!!.text}!" }) } }

To create a test for the MainActivity, we will start by creating a MainActivityTest class under the androidTest directory. Add the AndroidJUnit4 annotation to the class to indicate that the tests in this class will use the default Android test runner class.

@RunWith(AndroidJUnit4::class) class MainActivityTest {}

Next, add an ActivityTestRule to the class. This rule provides functional testing of a single activity. For the duration of the test, you will be able to manipulate your activity directly using the reference obtained from getActivity().

@Rule @JvmField var activityActivityTestRule = ActivityTestRule(MainActivity::class.java)

Now that you are done setting up the test class, let’s add a test that verifies that the user name is displayed by clicking the “Set User Name” button.

@Test fun setUserName() { onView(withId(R.id.name_field)).perform(typeText("Vivek Maskara")) onView(withId(R.id.set_user_name)).perform(click()) onView(withText("Hello Vivek Maskara!")).check(matches(isDisplayed())) }

The test above is quite simple to follow. It first simulates some text being typed in the EditText, performs the click action on the button, and then checks whether the correct text is displayed in the TextView.

The final test class looks like this:

@RunWith(AndroidJUnit4::class) class MainActivityTest { @Rule @JvmField var activityActivityTestRule = ActivityTestRule(MainActivity::class.java) @Test fun setUserName() { onView(withId(R.id.name_field)).perform(typeText("Vivek Maskara")) onView(withId(R.id.set_user_name)).perform(click()) onView(withText("Hello Vivek Maskara!")).check(matches(isDisplayed())) } } Running Your Instrumentation Tests

Just like for unit tests, click on the green play button in the IDE to run the test.

Large preview

Upon a click of the play button, the test version of the app will be installed on the emulator or device, and the test will run automatically on it.

Categories: World News

How AnyFlip Has Eased HTML5 Flipbook Publishing - The Newsman

Wed, 07/25/2018 - 15:19
This platform allows users to convert PDF files into HTML5 flipbooks within minutes. AnyFlip seeks to ease the process of publishing, reading, uploading, and sharing HTML5 flipbooks. Customized and Shareable Publications. AnyFlip offers publishers an ...

Categories: World News

GitHub’s Learning Lab launches free courses on open source collaboration and HTML

Wed, 07/25/2018 - 14:58

Earlier this year, GitHub announced Learning Lab — a portion of the site where users can learn the fundamentals of GitHub, and get advice on how to migrate to the service from other platforms. This was a smart move from GitHub. Learning Lab is growing rapidly, both in terms of users and content, and the company yesterday launched four new courses on the platform. They’re all fairly self-explanatory. Uploading to GitHub and Migrating to GitHub both talk about the fundamentals of the service, and how you can add a new project, or port over an existing one from a rival service,…

This story continues at The Next Web

Or just read more coverage about: GitHub
Categories: World News

Washable Lunch Bag

Wed, 07/25/2018 - 14:57

Oh! I like this washable, eco-friendly lunch bag by Pip Pottage.

Categories: World News

Cats Kill

Wed, 07/25/2018 - 14:57

I laugh every time I see this CATS KILL T-Shirt. But I guess it’s only funny if you live in the NYC area and are in the on the joke. (There’s an area upstate of NYC called The Catskills)

Categories: World News

Seven Principles for Belonging

Wed, 07/25/2018 - 14:57

The Art of Community by Charles Vogl is the first book to distill principles from 3,000 years of spiritual traditions for leaders to create belonging in any organization, field or movement. It is written to support mission driven leadership.

Categories: World News

For Strangers On The Internet

Wed, 07/25/2018 - 14:57

This made me smile. Here’s to keeping it real.

Categories: World News

Просто хороший хостинг