This is the post for the week of August 25, 2015.
This site is the official home for our Fall 2015 course (CRNs #83186 and #86919). Information on all assignments, weekly activities, and related resources will be posted here. Check this site regularly for the details on what to do for the course.
Readings for the Week of August 25
For today’s session, please read the following:
- The pages for the Syllabus and Assignments.
- Information on course logistics.
- Details on the characteristics of technical writing and chapter 1 of Markel.
- Suggestions for writing collaboratively and chapter 3 of Markel.
- The assignment for Project 1: Professional Biographies.
- Some tips on writing biographical statements for Project 1.
- Student Getting Started with Canvas Guide.
Work for the Week of August 25
This week is about making sure you understand the course policies, getting set up, and generally touching base with one another. If you have technical difficulty with this week’s class work, don’t panic! Send an email to tengrrl at vt.edu and let me know what you need help with.
Please complete these tasks by 11:55 PM on Monday, August 31:
Log into Canvas, using your PID and password. Contact 4HELP if you need assistance with your login. You can find help for Canvas 24/7 by using the Help link on the Canvas site and in the Canvas: Getting Started for Students article.
Confirm that your notifications in Canvas are set the way you want them. Note that Canvas uses your notification preferences to determine whether to email you or text you (or not tell you at all) about information in the site. See the section "How do I adjust my notification preferences?" in the Student Getting Started with Canvas Guide for more information on setting up your notifications.
- Verify that you understand how the course works:
Go to the Discussions tool (in the left menu in Canvas), and respond to these posts:
- If you have any questions about the syllabus or course logistics, reply to the Pinned Discussion for "Questions about the Syllabus and/or Course Logistics."
- Once you understand the information for the course and any questions you have are answered, reply to the Syllabus Verification Discussion to confirm that you have read the Syllabus and information on course logistics.
Begin work on Project 1:
- Go to the Discussions tool in Canvas, and choose the the “Readings for Project 1” topic. Discuss what you read in the Some tips on writing biographical statements with the members of your group.
- If you have any questions (today or in the future) about the first assignment, reply to the Pinned Discussion for "Questions about Project 1" topic in Canvas Discussions tool and add them. You can skim through this topic for answers as well.
Complete the quizzes for the week’s readings:
- Go to Quizzes in Canvas, and complete the reading quizzes on Chapter 1 and Chapter 3 of Markel. See the policies for quizzes on the course logistics page.


Welcome to my Home
After several years of using Googlesite, I decided it was time for my own domain
I hope you like my new home, please feel free to browse the information on this site.
To go with this site i have a You Tube channel, while i try to respond to any questions, i am not always notified, so if you have asked a question and haven't had an answer in a reasonable time, then please hop into discord or my forum.
This is a site that documents all my projects. I have great interest in high voltage, Audio and Visual, and many other things. Please take the time to read this site, you will most likely find something of interest in some of your projects,
I'm not just documenting my successes, but also my failures, but each failure is a learning process, just be careful you don't do the ultimate failure, [read any and all warnings] if you intend playing with voltages, even low voltage can kill in certain circumstances.
This site may change as time goes by.
You may freely link to any content or page. You may not hotlink any images etc You may copy any snippet of information providing you credit me with the creation


Hi Christopher, On Thu, Mar 26, 2020 at 07:40:06AM +0100, Christopher Faulet wrote: > Thanks ! However there are many problems with your patch. First there is no > commit message. You must explain what is exactly the problem and how you fix > it. Then, the documentation must be updated. You introduced 2 new options > without any explanation. Without these info, it is really hard to figure out > what the patch do.
I noticed these as well, thanks for pointing out before me :-) > But reading how headers and body buffers are inserted in > the request, I suspect some bugs. A reg-test is probably necessary to > validate such feature. Yes that would indeed be useful. > But, don't bother for now submitting a new patch. I'm currently refactoring > the tcp-checks. But on my todo list, the next big step is the http-check > refactoring. It is painful but I hope to finish the refactoring of the > checks for the 2.2.0. My main concern is the backward compatibility. Kiran's patch is small enough to be backported, so that might constitute a possible solution for existing setups. However we cannot afford to do that if it works differently than what we'll have in the final release. As such I think it's important to quickly figure how we want such a separate body part to be *configured* and make sure that it's done the same in your new version and in Kiran's patch. If so, then we could imagine merging it early to have it backported so that it's ultimately replaced in 2.2 by your work once ready. What do you think ? Thanks, Willy


As we continue to push the boundaries of technology, particularly in the automotive industry, it’s crucial that we prioritize the ethical development and deployment of Advanced Driver Assistance Systems (ADAS) and autonomous driving capabilities. Recent news highlights some of the challenges faced by industry leaders like Tesla, who faced a recall of 362,758 vehicles equipped with Full Self-Driving (FSD) Beta software due to safety concerns. Additionally, a class-action lawsuit alleges Tesla employees shared private, sometimes embarrassing photos and videos captured by car cameras without customers’ consent. These incidents serve as a reminder that transparency, privacy, and safety must be at the core of automotive data collection and utilization.
At Insight Autonomy, our mission is to create next-generation ADAS and autonomous vehicle components by leveraging the power of collective, user-generated driving data. We believe in democratizing this process to ensure that it is equitable, ethical, and accessible to everyone. Our approach to data collection involves obtaining explicit consent from our users and providing them with a clear understanding of how their data will be used. We are committed to preserving individual privacy and continuously developing measures to prevent unauthorized access or misuse of the data we collect.
The development of safer and more robust ADAS relies on a diverse and extensive dataset. By involving the wider driving community, we can create systems that are better equipped to handle the complexities of real-world driving scenarios. Transparent and ethical data collection practices not only benefit the end-users but also enhance the public’s trust in these advanced technologies. This trust is essential for the widespread adoption of ADAS and autonomous vehicles.
In conclusion, the democratization of automotive data collection is crucial to achieving safer ADAS and preserving individual privacy. By focusing on transparency, ethics, and user consent, we can pave the way for a future where advanced driving technologies are both accessible and trusted by the public. At Insight Autonomy, we are dedicated to making this future a reality and working together with our users to drive change in the automotive industry.


PolandBall is standing in a row with Many Other Balls. More precisely, there are exactly n Balls. Balls are proud of their home land — and they want to prove that it's strong.

The Balls decided to start with selecting exactly m groups of Balls, each consisting either of single Ball or two neighboring Balls. Each Ball can join no more than one group.

The Balls really want to impress their Enemies. They kindly asked you to calculate number of such divisions for all m where 1 ≤ m ≤ k. Output all these values modulo 998244353, the Enemies will be impressed anyway.


Let's denote the median of a sequence $$$s$$$ with odd length as the value in the middle of $$$s$$$ if we sort $$$s$$$ in non-decreasing order. For example, let $$$s = [1, 2, 5, 7, 2, 3, 12]$$$. After sorting, we get sequence $$$[1, 2, 2, \underline{3}, 5, 7, 12]$$$, and the median is equal to $$$3$$$.

You have a sequence of $$$n$$$ integers $$$[1, 2, \dots, n]$$$ and an odd integer $$$k$$$.

In one step, you choose any $$$k$$$ elements from the sequence and erase all chosen elements except their median. These elements do not have to go continuously (gaps are allowed between them).

For example, if you have a sequence $$$[1, 2, 3, 4, 5, 6, 7]$$$ (i.e. $$$n=7$$$) and $$$k = 3$$$, then the following options for the first step are possible:

- choose $$$[1, \underline{2}, 3]$$$; $$$2$$$ is their median, so it is not erased, and the resulting sequence is $$$[2, 4, 5, 6, 7]$$$;
- choose $$$[2, \underline{4}, 6]$$$; $$$4$$$ is their median, so it is not erased, and the resulting sequence is $$$[1, 3, 4, 5, 7]$$$;
- choose $$$[1, \underline{6}, 7]$$$; $$$6$$$ is their median, so it is not erased, and the resulting sequence is $$$[2, 3, 4, 5, 6]$$$;
- and several others.

You can do zero or more steps. Can you get a sequence $$$b_1$$$, $$$b_2$$$, ..., $$$b_m$$$ after several steps?

You'll be given $$$t$$$ test cases. Solve each test case independently.


/*
 * Copyright (c) 2017-2021, Alibaba Group Holding Limited
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _PFSD_WORKER_H_
#define _PFSD_WORKER_H_

#include <pthread.h>
#include "pfsd_proto.h"
#include "pfsd_common.h"

struct pfsd_iochannel;

extern volatile bool g_stop;

/*A worker thread is dedicated to a shm */
typedef struct worker {
	pthread_t w_tid;
	int w_idx;
	int w_nch;
	struct pfsd_iochannel *w_channels[PFSD_SHM_MAX  *PFSD_WORKER_MAX];
	sem_t w_sem; /*for sync start thread */
	pfsd_cpu_record_t *w_cr; /*if it set affinity */
} worker_t;

extern worker_t *g_workers;
extern int g_nworkers;

worker_t *pfsd_create_workers(int nworkers);
void pfsd_destroy_workers(worker_t **workers);

void *pfsd_worker_routine(void *arg);

extern pfsd_cpu_record_t *g_cpufile;
extern int g_ncpu;
/*Exec in main thread when start, find available core for worker threads */
void *pfsd_worker_affinity_prepare(int nworkers);
bool pfsd_worker_bind_cpuset(worker_t *worker);
bool pfsd_is_busy_cpu(int cpuid, int ncpu);

int pfsd_worker_handle_request(pfsd_iochannel *ch, int index);

void pfsd_worker_handle_growfs(pfsd_iochannel *ch, int index, const growfs_request_t *req, growfs_response_t *rsp);
void pfsd_worker_handle_rename(pfsd_iochannel *ch, int index, const rename_request_t *req, rename_response_t *rsp);
void pfsd_worker_handle_open(pfsd_iochannel *ch, int index, const open_request_t *req, open_response_t *rsp);
void pfsd_worker_handle_read(pfsd_iochannel *ch, int index, const read_request_t *req, read_response_t *rsp);
void pfsd_worker_handle_write(pfsd_iochannel *ch, int index, const write_request_t *req, write_response_t *rsp);
void pfsd_worker_handle_truncate(pfsd_iochannel *ch, int index, const truncate_request_t *req, truncate_response_t *rsp);
void pfsd_worker_handle_ftruncate(pfsd_iochannel *ch, int index, const ftruncate_request_t *req, ftruncate_response_t *rsp);
void pfsd_worker_handle_unlink(pfsd_iochannel *ch, int index, const unlink_request_t *req, unlink_response_t *rsp);
void pfsd_worker_handle_stat(pfsd_iochannel *ch, int index, const stat_request_t *req, stat_response_t *rsp);
void pfsd_worker_handle_fstat(pfsd_iochannel *ch, int index, const fstat_request_t *req, fstat_response_t *rsp);
void pfsd_worker_handle_fallocate(pfsd_iochannel *ch, int index, const fallocate_request_t *req, fallocate_response_t *rsp);
void pfsd_worker_handle_chdir(pfsd_iochannel *ch, int index, const chdir_request_t *req, chdir_response_t *rsp);
void pfsd_worker_handle_mkdir(pfsd_iochannel *ch, int index, const mkdir_request_t *req, mkdir_response_t *rsp);
void pfsd_worker_handle_rmdir(pfsd_iochannel *ch, int index, const rmdir_request_t *req, rmdir_response_t *rsp);
void pfsd_worker_handle_opendir(pfsd_iochannel *ch, int index, const opendir_request_t *req, opendir_response_t *rsp);
void pfsd_worker_handle_readdir(pfsd_iochannel *ch, int index, const readdir_request_t *req, readdir_response_t *rsp);
void pfsd_worker_handle_access(pfsd_iochannel *ch, int index, const access_request_t *req, access_response_t *rsp);
void pfsd_worker_handle_lseek(pfsd_iochannel *ch, int index, const lseek_request_t *req, lseek_response_t *rsp);

/*for debug : return current processing request's pid  */
pid_t pfsd_worker_current_processing_pid();

#endif


After you create and enable a SAML authenticator for the identity provider you want to use, you might need to generate Connection Server metadata. You use this metadata to create a service provider on the Unified Access Gateway appliance or a third-party load balancer that is the identity provider.
Verify that you have created a SAML authenticator for the identity provider: Unified Access Gateway or a third-party load balancer or gateway.
- Open a new browser tab and enter the URL for getting the Connection Server SAML metadata.
In this example, connection-server.example.com is the fully qualified domain name of the Connection Server host.This page displays the SAML metadata from Connection Server.
- Use a Save As command to save the Web page to an XML file.
For example, you could save the page to a file named connection-server-metadata.xml. The contents of this file begin with the following text:
<md:EntityDescriptor xmlns:md="urn:oasis:names:tc:SAML:2.0:metadata" ...
What to do next
Use the appropriate procedure on the identity provider to copy in the Connection Server SAML metadata. Refer to the documentation for Unified Access Gateway or a third-party load balancer or gateway.


A tree is a connected undirected graph without cycles. Note that in this problem, we are talking about not rooted trees.

You are given four positive integers $$$n, d_{12}, d_{23}$$$ and $$$d_{31}$$$. Construct a tree such that:

- it contains $$$n$$$ vertices numbered from $$$1$$$ to $$$n$$$,
- the distance (length of the shortest path) from vertex $$$1$$$ to vertex $$$2$$$ is $$$d_{12}$$$,
- distance from vertex $$$2$$$ to vertex $$$3$$$ is $$$d_{23}$$$,
- the distance from vertex $$$3$$$ to vertex $$$1$$$ is $$$d_{31}$$$.

Output any tree that satisfies all the requirements above, or determine that no such tree exists.


Hello all, I got attacked while i was online, I have 2 devices and switch between them regularly. This has happened to me multiple times. It should not put me offline instant I am switching between IOS devices. I just lost 500k gold just because of this. Really frustrating.
You got attacked because you was offline, So you know why you got attacked. The second you leave the game the wolves will sniff you out.
You close the game and you immediately turn Offline… and you can be attacked the second you do this, then you get what my profile picture shows.
I turned the game on, on the second device first. It goes online. Then i turned the first device off. This actually works most of the time.
My suspicion is that if I forget to turn off the first device it goes to offline mode. Then that triggers attackable meanwhile i’m online on the second device doing my raids and no notification till I go back to the first device.
Trust me I been keeping good eye staying online and not turning the devices off while I have the loot. But the iphone doesn’t have a lot of battery and my old Ipad isn’t great for gaming.
I can give a suggestion using methods like COC(clash of clans) does. where it will disconnect the first device automatically when you connect on second device. This way you know only one device is online at a time. This would prevent problems like this.
You have about 2-3 minutes before the game says you are offline and as soon as that 2 min or close to 2 min timer hits you are free game to anyone and even if you log back in you can be attacked and see the icon in the top left that you are being raided. A lot of people are raiding nonstop and if you happen to pop up in the randoms list as I have noticed a lot of times the random list like to pick people that just logged off there. OR if someone is watching and eyeing your gold because it is high they will sit there and spam attempt attack you until it works or you spend your gold.
I know of people that for a hour straight try to farm one dude cause he had like 2mil showing
Dont get me wrong i do the same thing personally love that part of the game. I repeatedly go out and in to refresh the loot (this needs a refresh button instead
This can test this with connected 2 devices with a lot of loot, keep one device connected while other one slowly goes offline and shows the king message.
So then this might rather be considered a bug and belong to the “bug reports & technical help” section? (Leaving it here for now for further discussion, though.)
I see this can be annoying, though I guess fixing it is absolutely low priority to Flaregames as most players just have only one device or are online at only 1 device at any time…
However, as Bladestorm pointed out, when you exit the game (being only online on 1 device), you have some time before the game actually treats you as offline. Times for this might vary a bit, but it should be more than long enough to load up the game again on the same or another device.
Thus I guess it might actually be better to 1. exit the game on your first device, then 2. enter the game on your second device. This way only on 1 device you’re logged in at any time, and the few seconds where you are not logged in on any of them are covered by the threshold duration between logging off and being treated as offline/raid-able.
Closing the app first and launching then on second device seems like good solution time being. What is the exact duration till you are marked as attackable? Im guessing its around a min or 2 but what is it exactly would help a lot on other stuff too, like checking a text message.
I’m not sure whether or not a required re-log after switching to a different app and back also means you’ve been marked attackable immediately, but at least that time varies for me.
E.g. once clicked a chat notification (for some other app), read new chat messages for like 10-15 seconds, switched back to RR2 and got shown the login/loading screen. At other times I were in some other app for like 40 seconds, then switched back and game was still logged in and continued just as normal (even during a paused raid).
Though, I don’t know whether the “mark as attackable” timer might be fixed or varying too…
As a rule of thumb I use “hurry and switch back as soon as possible” and switch between apps back and forth a few times in a row if I need to read a longer message that I couldn’t read at once without relogging.


CYsmart is a patented solution for the industrial IoT.
The perfect fusion of hardware and software in which we have integrated Smart Edge Computing ™ technology.
This "end to end" solution is unique in the industrial IoT market.
Our solution continues to develop new skills, our Team too.
A complete and competent team at the service of the digital transition with the will to allow an intelligent analysis closer to the industrial data.


Monocarp is a little boy who lives in Byteland and he loves programming.

Recently, he found a permutation of length $$$n$$$. He has to come up with a mystic permutation. It has to be a new permutation such that it differs from the old one in each position.

More formally, if the old permutation is $$$p_1,p_2,\ldots,p_n$$$ and the new one is $$$q_1,q_2,\ldots,q_n$$$ it must hold that $$$$$$p_1\neq q_1, p_2\neq q_2, \ldots ,p_n\neq q_n.$$$$$$

Monocarp is afraid of lexicographically large permutations. Can you please help him to find the lexicographically minimal mystic permutation?


#pragma once

#include "mvTypeBases.h"
#include "mvApp.h"
#include "mvModule_Core.h"
#include <string>

namespace Marvel {

    MV_REGISTER_WIDGET(mvKnobFloat, MV_ITEM_DESC_DEFAULT, StorageValueTypes::Float, 1);
    class mvKnobFloat : public mvFloatPtrBase
    {

    public:

        static void InsertParser(std::map<std::string, mvPythonParser>* parsers);

        MV_APPLY_WIDGET_REGISTRATION(mvAppItemType::mvKnobFloat, add_knob_float)

        MV_START_EXTRA_COMMANDS
        MV_END_EXTRA_COMMANDS

        MV_START_GENERAL_CONSTANTS
        MV_END_GENERAL_CONSTANTS

        MV_START_COLOR_CONSTANTS
        MV_END_COLOR_CONSTANTS

        MV_START_STYLE_CONSTANTS
        MV_END_STYLE_CONSTANTS

    public:

        mvKnobFloat(const std::string& name);

        void draw(ImDrawList* drawlist, float x, float y) override;

        void handleSpecificKeywordArgs(PyObject* dict) override;
        void getSpecificConfiguration(PyObject* dict) override;

    private:

        float m_min = 0.0f;
        float m_max = 100.0f;
        float m_step = 50.0f;

    };

}


Bearland is a big square on the plane. It contains all points with coordinates not exceeding 106 by the absolute value.

There are n houses in Bearland. The i-th of them is located at the point (xi, yi). The n points are distinct, but some subsets of them may be collinear.

Bear Limak lives in the first house. He wants to destroy his house and build a new one somewhere in Bearland.

Bears don't like big changes. For every three points (houses) pi, pj and pk, the sign of their cross product (pj - pi) × (pk - pi) should be the same before and after the relocation. If it was negative/positive/zero, it should still be negative/positive/zero respectively. This condition should be satisfied for all triples of indices (i, j, k), possibly equal to each other or different than 1. Additionally, Limak isn't allowed to build the house at the point where some other house already exists (but it can be the point where his old house was).

In the formula above, we define the difference and the cross product of points (ax, ay) and (bx, by) as:

(ax, ay) - (bx, by) = (ax - bx, ay - by),

(ax, ay) × (bx, by) = ax·by - ay·bx.

Consider a set of possible new placements of Limak's house. Your task is to find the area of that set of points.

Formally, let's say that Limak chooses the new placement randomly (each coordinate is chosen independently uniformly at random from the interval [ - 106, 106]). Let p denote the probability of getting the allowed placement of new house. Let S denote the area of Bearland (S = 4·1012). Your task is to find p·S.


There's a chessboard of size $$$n \times n$$$. $$$m$$$ rooks are placed on it in such a way that:

- no two rooks occupy the same cell;
- no two rooks attack each other.

A rook attacks all cells that are in its row or column.

Is it possible to move exactly one rook (you can choose which one to move) into a different cell so that no two rooks still attack each other? A rook can move into any cell in its row or column if no other rook stands on its path.


DHCPv6 guard feature blocks DHCP reply and advertisement messages that originate from unauthorized DHCP servers and relay agents that forward DHCP packets from servers to clients. Client messages or messages sent by relay agents from clients to servers are not blocked. The filtering decision is determined by the device role assigned to the receiving switch port, trunk, or VLAN. This functionality helps to prevent traffic redirection or denial of service (DoS).
Let's discussed about common problem scenario also called man-in-middle attack:
We’ve got our multilayer switch in the center and somewhere off to the side of router R1,we’ve got a DHCPv6 server which is our legitimate device. And in our access domain on the down we have our victim, who is a person coming into work on a normal morning, turning on his Laptop and requesting a DHCPv6 address with a solicit message. Unfortunately for him, a neighbor of his is the rogue man sitting next to him in the cubicle, can see his DHCP solicit message and can actually reply, pretending that he is the DHCPv6 server and assign credentials and…such as the DNS address to be used etc. and which he can use then to redirect traffic to himself. So, unprotected, this would be a very dangerous position. So for people to protect themselves in this sort of network layer by simply turning on IPv6 Snooping. By turning on IPv6 Snooping, you automatically drop the switch into “Guard Mode” which will turn on DHCPv6 Guard as well as RA Guard; so none of the redirect advertisements or any DHCPv6 server messages will get through.
There are two mode:
1) Client: Sets the role of the device to client.
2) Server: Sets the role of the device to server.
Since the default mode of the switch is to “guard”, by default all ports configured with dhcpv6 guard will be in client mode. Thus all ports will be dropping any dhcpv6 server messages by default.
Additional security can be achieved by assigning an access list to only permit dhcpv6 server messages from a specific source address. Assigning a prefix-list to allow address allocation only from a known prefix (i.e. the server has been compromised).
1) 1st Assign Policy for Hosts:
For the Host facing ports you don’t need to do this, but if you want to explicitly configure this, that’s how you do it.
SW1(config)#ipv6 dhcp guard policy dhcp-client
Interface range fa0/2-3
switchport mode access
ipv6 dhcp guard attach-policy dhcp-client
2) Then assign policy for DHCP server facing port:
For the server facing ports, you need create DHCPv6 Guard policy.
SW1(config)#ipv6 dhcp guard policy dhcp-server
SW1(config-dhcp-guard)#match server access-list ACL1
You can also provide some extra functionality over access lists; you could block server messages for particular addresses using an access list and you could also block some advertisements from the DHCPv6 server blocking certain prefixes using a prefix list as shown below:
SW1(config)#ipv6 access-list ACL1
SW1(config-ipv6-acl)#permit ipv6 host FE80::1 any
SW1(config)#ipv6 prefix-list PREF1 seq 5 permit 2001::/64 le 128
switchport mode access
ipv6 dhcp guard attach-policy dhcp-server
SW1#show ipv6 dhcp guard policy
Dhcp guard policy: dhcp-client
Device Role: dhcp client
Target: fa0/2 fa0/3
Dhcp guard policy: dhcp-server
Device Role: dhcp server
Max Preference: 255
Min Preference: 0
Source Address Match Access List: ACL1
Prefix List Match Prefix List: PREF1
SW1#show ipv6 access-list ACL1
IPv6 access list ACL1
permit ipv6 host FE80::1 any (5 matches) sequence 10
Has anyone got Cisco Nexus 9000v to run on Vsphere 7.x? I can't seem to get Nexus 9000v 9.3 to run on ESXi 7.02. The image appears to boot but stops with 'Boot Time <date time> as the last line displayed on the console. I have gotte...
Which two commands must be configured on the New York router so that it reaches the Lo1 interface of the Atlanta router via Washington when the link between New York and Atlanta goes down? I am a bit confused which static route i must use to solve that. I...
Please help - is there a way to establish a fault tolerant connection between the 4321 ISR router and the 2960 or IE2000 switch?Writing bachelor's work, doing a simulation at Cisco Packet Tracer. The HSRP activation command is not accepted by the sim...
Hello folks, I am looking to purchase the following switch as Layer 3 C9300X-24Y-A and following switch as Layer 2 C9200L-48P-4X-E. The current old switches 3850 & 3650 that are being replaced have the following SFP for the most part "SFP-10...
Somehow I am not understanding the scant documentation on setting default routes for multiple circuits in VPN 0. It works for me with more than one circuit if they all are static IPs with static next hops. It works for a single circuit with DHCP. However,...


/**************************************************************

This file is a part of
https://github.com/atiderko/esp8266-ansulta-alexa
Copyright (c) 2018 Alexander Tiderko

Licensed under MIT license

Configuration class to setup WiFi settings using
WiFiManager [https://github.com/tzapu/WiFiManager].
It is also possible to reset the configuration by double press
on reset. The idea is based on
https://github.com/datacute/DoubleResetDetector

**************************************************************/
#ifndef CONFIG_H
#define CONFIG_H

#include <FS.h>
#include <DNSServer.h>
#include <WiFiManager.h>

#define CONFIG_FILE "/ansulta_config.json"
#define ANSULTA_AP "AnsultaAP"
#define AP_PASSWORD "ansulta"

static char HUE_DEVICE_NAME[] = "Küchenlicht";

// use reset idea from https://github.com/datacute/DoubleResetDetector
#define RESET_UTC_ADDRESS 127
#define RESET_FLAG 0x12121212
#define RESET_FLAG_CLEAR 0x10000001

class Config {
public:
    static const unsigned long MOTION_TIMEOUT = 0; // millis, 0 disables motion
    static const int MAX_PHOTO_INTENSITY = 100;

    String device_name;
    unsigned long motion_timeout;
    int max_photo_intensity;
    Config();
    ~Config();
    void setup();
    void loop();
    bool is_connected();
    bool has_motion();
    void should_save_config();
    void save_ansulta_address(byte address_a, byte address_b);
    byte get_ansulta_address_a();
    byte get_ansulta_address_b();

protected:
    //flag for saving data
    bool pShouldSaveConfig;
    byte pAnsultaAddressA;
    byte pAnsultaAddressB;
    bool p_has_motion;
    void p_save_config();
    bool has_flag(int address, uint32_t flag);
    void set_flag(int address, uint32_t flag);
    WiFiManager wifiManager;
};

#endif


Learn about how to send a message to your Microsoft Teams channel when a rule is fired in your IoT Central app using Microsoft Flow. We’ll cover what is Microsoft Flow, and go through how to build workflows easily using the hundreds of connectors available. Get more details about continuous data export in docs: https://docs.microsoft.com/en-us/azure/iot-central/howto-add-microsoft-flowCreate
Azure Functions is a serverless compute service that enables you to run code on-demand without having to explicitly provision or manage infrastructure. Using Azure Functions, you can run a script or piece of code in response to a variety of events. Azure Data Factory (ADF) is a managed data integration service in Azure that enables
In this episode, we dive into some of the new features available in Workbench 1.6, such as application versioning and troubleshooting. You can try Workbench here: https://aka.ms/tryworkbench Details on latest updates in Workbench here: https://aka.ms/workbenchreleasenotes Azure Blockchain Workbench 1.6.0 blog Follow @CH9 Follow @MSFTBlockchain Link to Channel9
This Week on Channel 9, Christina is ready to report on the latest developer news, including: [00:20] Microsoft Ignite: The Tour continues to ramp up. [00:48] Microsoft IoT and AI stuff at CES 2019 and some Windows device highlightsfrom CES. [01:37] GitHub Offers Unlimited Free Private Repos [02:40] Updates to GitHub Pull Request Extension for VS Code [03:05] Python 2.7 Support for App
Chris Anderson joins Donovan Brown to discuss how to use Azure Cosmos DB and other great Azure services to build a highly-scalable, real-time, collaborative application. You’ll see techniques for using the Azure Cosmos DB change feed in both Azure Functions and SignalR applications. We also briefly touch on how custom authentication works with Azure Functions.
Accelerate your career in one of the fastest-growing cloud technology fields: IoT. This program will teach you the device programming, data analytics, machine learning, and solution design skills you need for a successful career in IoT. Learn the skills necessary to start or progress a career working on a team that implements IoT solutions. Get
What is it like to intern at Microsoft? Scott Hanselman meets with three interns from the Microsoft Explorer Program (a cross-discipline internship designed for college freshmen and sophomores) to talk about their experience working on the Azure Container Registry and their contribution of ACR Build and Task capabilities to the Visual Studio Code Docker Extension.
On this week’s Xamarin Show, James is joined by good friend Christos Matskas who shows off a beautiful Xamarin application that is infused with AI to generate a full Azure backend just by drawing pictures on a white board. You don’t want to miss this mind blowing demo and walkthrough of the code. Show Notes:
Winvision has leveraged the spatial intelligence capabilities of Azure Digital Twins to build BeSense, a smart building application that provides realtime data that optimizes space utilization and occupant experience. Remco Ploeg, a Solution Architect at Winvision demos the application. Learn more about BeSense: https://www.besense.nl/en Learn more about Winvision: https://www.winvision.nl Learn more about Azure Digital
This episode will introduce the use of IPFS (Interplanatory File System) in a consortium setting. The concepts of how this technology can be helpful to remove centralization of storage that is not part of the block in the blockchain is shown. Along with this is a short demonstration of how the marketplace offering for IPFS


LuoTianyi gives you a palindrome$$$^{\dagger}$$$ string $$$s$$$, and she wants you to find out the length of the longest non-empty subsequence$$$^{\ddagger}$$$ of $$$s$$$ which is not a palindrome string. If there is no such subsequence, output $$$-1$$$ instead.

$$$^{\dagger}$$$ A palindrome is a string that reads the same backward as forward. For example, strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.

$$$^{\ddagger}$$$ A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters from $$$b$$$. For example, strings "a", "aaa", "bab" are subsequences of string "abaab", but strings "codeforces", "bbb", "h" are not.


OCP has launched a new software feature functionality that will allow visitors to the OCP Marketplace to view the various software stacks supported on OCP Accepted™ and OCP Inspired™ hardware platforms. This new feature will allow visitors to the OCP Marketplace to make more informed buying decisions. The OCP Foundation hopes that this feature will further illustrate our commitment to software solutions in addition to the variety of open sourced hardware solutions.
With the addition of this new feature, a visitor to the OCP Marketplace (https://www.opencompute.org/products) will see a new category called “Software”, listed on the left hand side of the component tree area of the website.
Based on the above picture, if a user selects the “Server” and a “Software” category, then all the software supported on a particular server platform will be displayed.
If a user selects the “Network” category, then all the network software supported on a particular switch platform will be displayed.
A user can also perform searches for a particular software stack supported on a hardware platform.
More software features and functionality will be launching in the next few days so check back here for updates.


I have been using the following code for years to create a SQL string from an expression with the parameters filled in:
public static string ToUnparameterizedSelectStatement<T>(this SqlExpression<T> expression)
string s = expression.ToSelectStatement();
foreach (var p in expression.Params)
s = s.Replace(p.ParameterName, p.Value.ToString());
I recently stumbled across the
SqlExpression which I thought would be a good idea to use and replace my custom code with the built in one.
However this gave me a serious performance regression as seen in the before and after below. Any idea why this would be?
To find out what the differences are, check the implementations, here's
MergeParamsIntoSql() which it calls:
Which uses Regex which is obviously going to perform worse vs a simple string replace in a micro benchmark. Also you're just doing a simple string embed whereas OrmLite uses the registered converters to embed the proper quoted db value. Your solution is going to break when replacing parameters which share the same prefix, e.g.
@p10. I also remember having to update this once to handle a corner case you've reported.
You would only use this once in a query, i.e. it's not called in a hotspot loop.
There's a hot spot I have where this is being called where I want to use the result of
ToMergedParamsSelectStatement to check if this query exists in a cache before hitting the database.
Maybe there's a better way to generate a key for a cache based on a
Based on any SqlExpression no, you can keep using you’re impl since it doesn’t have to be correct and just needs to generate a unique string.
Generally I’d be caching higher up and using a serialized Request DTO or RawUrl as the cache key or for internal queries just a name + serialized args, I.e. never a generic SqlExpression.


2.1. Percolation Theory
 A system of pores that have low interconnectivity is best approached as a percolation problem [Sahimi, 1994; Hunt and Ewing, 2009]. Unfortunately, few hydrologists and soil scientists (the authors included) learned percolation theory as students, so the topic often seems a confusing morass from which we do not know how to extract the relationships we want. Here we present some basic concepts of percolation theory, as background for applying it to diffusive exchange between a porous sphere and the surrounding fluid.
 Percolation theory [Stauffer and Aharony, 1994] is a mathematical framework for describing the macroscopic properties that emerge in a system composed of many roughly equivalent parts, given the local degree of connection between those parts. In the context of this study, the parts are the individual pores within a single particle (grain, cobble, etc.), and the macroscopic properties of chief interest are the accessible porosity and the intragranular diffusion coefficient. Ewing et al.  discussed why it is reasonable to expect that many geological media have low pore connectivity; here we will briefly discuss how some properties emerge as a consequence of low connectivity. Extensive presentations of percolation theory in the context of porous materials are given in the work of Berkowitz and Balberg , Sahimi , and Hunt and Ewing .
 Consider a large two-dimensional lattice, for example a brick wall, and suppose that individual sites (e.g., bricks) are colored black with probability p, or white with probability 1 − p. As p increases from 0, black sites change from being rare and isolated, to occurring in clusters of black sites. Further increases in p increase the mean size of the black clusters, and eventually a threshold is crossed: the black clusters merge to form an “infinite cluster” that spans the entire brick wall, however large it may be. The value of p at which the percolation threshold is reached (the infinite cluster forms) is called pc, the critical probability. When p > pc, the white sites occur as disconnected clusters, and further increasing p will decrease the mean size of the white clusters until they become rare and isolated. Much of percolation theory can be developed from this simple sketch.
 When p = 1.0, all sites are black, so all sites are on the infinite cluster. When p < pc, no black site are on the infinite cluster because there is no infinite cluster. The fraction of black sites that belong to the infinite cluster (denoted P, the “power” of the infinite cluster) therefore goes from 0 for p < pc, to 1 at p = 1. As it happens, P is described by a simple power law: when p > pc, P ∼ (p – pc)β. This behavior is independent of (most) details of the lattice: even though square, triangular, cubic, and irregular lattices have different values for pc, the same power law behavior is seen in all of them, a phenomenon known as universality. The value of β is different in different dimensions, but values are known for both two and three dimensions (Table 1). A consequence of universality is that relationships developed for an easy case, say a square two-dimensional lattice, can then be applied (with some care) to irregular three-dimensional problems.
Table 1. Fundamental Percolation Exponents Discussed in This Study
|Exponent||Value in 2-D||Value in 3-D||Meaning|
|β||5/36a||0.41||Defines the fraction of the medium that is on the infinite cluster (the “power” of the infinite cluster).|
|ν||4/3||0.88||Defines χ, the fundamental length scale near pc. Indicates size-scaling.|
| ||1.13||1.34||Fractal dimension of the chemical path between two points on the same cluster; related to tortuosity.|
|μ||1.31||2.0||Describes conductivity near pc in an infinite medium.|
 A useful parameter is the correlation length, χ. For p < pc, χ is essentially the mean radius of the finite clusters, while for p > pc, χ is the mean radius of the holes in the infinite cluster. This has practical implications: if only the black phase is conducting, then pathways through the black infinite cluster are on average separated by a distance χ; this is why χ is also called the “mean separation of paths.” χ is known to scale as χ ∼ |p – pc|−ν, and the presence of the percolation exponent ν (Table 1) generally indicates some form of size scaling. χ functions as a characteristic length, and we find that systems behave homogeneously at length scales L ≫ χ, while behavior at scales less than χ is typically scale dependent. Because χ ∞ as p pc, the only operational length scale at pc is the system size.
 Suppose a system is near pc, and we want to know the length of a path between two given sites on the same cluster. The straight line or Euclidean distance, l, can be calculated trivially, but the connecting pathway, proceeding from site to connected site, is more complex. The length of this path is called the chemical distance, λ, because in a porous medium, with sites corresponding to pores, this is the shortest path available to a molecule traveling between the two sites. The path is fractal at scales greater than the scale of individual sites but less than χ; for these distances λ is related to the Euclidean distance as (Table 1). The ratio λ/l is therefore the tortuosity τ, the value of which must be scale dependent at scales greater than a single pore and less than χ [Ewing et al., 2010].
 As a final illustration, consider conduction through the infinite cluster. If p = 1, the system's conductivity, g, is clearly determined by the distribution of conductivities. But as p decreases toward pc, the individual conducting pathways become more tortuous (with ), while the separation between individual pathways becomes greater (with ν). At some point [Hunt, 2004; Ewing and Hunt, 2006] the topological considerations become more important than the conductivity distribution, and the system's conductivity is found to scale with proximity to the percolation threshold as g ∼ (p – pc)μ (Table 1).
 Instead of having sites be black with probability p (“site percolation”), we could have had bonds (the connections between adjacent sites) being active with probability p (“bond percolation”). The values of the critical probabilities, and of the prefactors needed to convert the scaling relationships to equalities, are specific to the lattice used (square, honeycomb, etc.), and whether it is site or bond percolation that obtains. However, the scaling relationships we have shown hold generally across these as well as other considerations. Our RW model uses bond percolation on a simple cubic lattice, so we know that pc ≈ 0.2488 [Stauffer and Aharony, 1994]. In a physical system (e.g., Borden sand), we do not know either p or pc, so different methods must be found to work with percolation concepts. Both conceptual and physical systems are considered in this study.
2.2. Model Development
 When accessible porosity is not uniform, a FD model needs local values of accessible porosity in order to convert between concentration (the driving force) and solute mass. Our FD model therefore requires equations giving local values of both accessible porosity, φa, and the diffusion coefficient, pm. When the sphere has low pore connectivity, these parameters vary as functions of both the proximity to the percolation threshold (i.e., with p – pc), and the intragranular distance l to the sphere's exterior. We address the accessible porosity first. Recall that the percolation exponent β gives the fraction of active sites that are on the infinite cluster, and in an infinite system, only sites on the infinite cluster would be accessible over great distances. Meanwhile, scaling with distance occurs for distances l < χ. The value of χ for a system above the percolation threshold is given by χ = a (p – pc)−ν, with a being a system-specific prefactor. The β and ν exponents combine to give an exponent –β/ν, which governs how accessible porosity varies with distance from the exterior. If p and pc are known (e.g., when comparing the FD model with the RW model) then a is a fitting parameter; for a physical system (e.g., the Borden sand) we instead consider χ to be a fitting parameter.
 At distances l > χ, φa takes a constant plateau value which we designate φp. Closer to the exterior, φa decreases with an exponent –β/ν. Equating these at l = χ defines a prefactor b ≡ φpχβ/ν, so
where the scaling with distance shows up through both the exponent ν, and the crossover in scaling at l = χ (Figure 1). With these relationships, and given χ and φp for a sphere of radius R, then φa for the whole sphere can be calculated as
and given any three of [R, χ, φp, φa], we can calculate the fourth.
 When modeling the sphere without distinguishing between the infinite and finite clusters (the “merged” model), equation (2) suffices to describe the porosity distribution. But when modeling the infinite and finite clusters as separate systems operating in parallel (the “split” model), their accessible porosities must be treated separately. All accessible porosity must be on either the infinite cluster (φi) or those finite clusters intersecting the edge (φf): φa = φi + φf. Accessible porosity on the infinite cluster varies with intragranular distance l to the grain's exterior as
 By definition, all accessible pores at distances l > χ belong to the infinite cluster (Figure 1). Consequently, accessible porosity due to the finite clusters, φf, is nonzero only for l < χ, and is given by the difference between equations (2) and (4):
When the sphere is small relative to the correlation length (i.e., when R < χ), there is no infinite cluster. In this case we consider that the split and merged models are identical.
 The FD model also requires a percolation-based estimate of the diffusion coefficient, pm. As with φa, two distinct scaling issues apply: scaling with distance l from the sphere's exterior, and scaling with p – pc, the proximity to the percolation threshold. As with porosity, diffusion scaling with distance has a crossover at l = χ, and is known to take the form [Stauffer and Aharony, 1994]
where the exponent ϑ ≡ (μ – β)/ν ≈ 1.807 in 3-D. As we would expect, this distance-scaling exponent has the exponent ν in the denominator.
 The second kind of scaling, scaling with p – pc for distances l > χ, was seen by Ewing et al.  to follow
They gave the exponent ψ ≈ 1.42 in 3-D, and conjectured that ψ ≡ (2 + ϑ)/2 . On the other hand, Havlin and Ben-Avraham  and Stauffer and Aharony  give the exponent ψ ≡ 2ν – β (≈1.35 in 3-D) for p < pc, which is to say, for finite clusters near criticality. This exponent can be interpreted as meaning that diffusion is restricted to a single pathway (on average) through each area χ2 (because the mean distance between paths scales with the exponent –ν), and is directly proportional to the fraction of the porosity that is on the infinite cluster (controlled by the β exponent). For comparisons against the RW model, we ran the FD model with both values of ψ.
 Because diffusion and conductivity are related, one might expect that the relevant exponent would be μ rather than ψ. The short explanation is that in our porous spheres we have diffusion on both the infinite cluster and the finite clusters; when diffusion is restricted to the infinite cluster, the μ exponent is appropriate. A fuller explanation [e.g., Stauffer and Aharony, 1994] is beyond the scope of this paper.
 Equation (7) is problematic in terms of actual implementation, most obviously because the endpoints are wrong. For example, we may want pm at p = 1.0 to take some known value (denoted k), and can easily normalize to obtain it. But equation (7) would also give pm = 0 at p = pc, which is only asymptotically true for infinite systems, in contrast to the finite spheres we are considering. Specifically, if we are working with a grain of size R ≤ χ, all intragranular pores lie within the region of decreasing porosity and increasing tortuosity (Figure 1). Within this region, all values of p between pc at the low end, and pc + (R/a)−1/ν at the high end, should give identical values of the diffusion coefficient (combining both the infinite and finite clusters): all of these systems behave essentially identically within a distance l < χ of the exterior [Ewing et al., 2010, Figure 10]. We therefore modify equation (7) to
This modification is further justified in section 5. Combining the two kinds of scaling (equations (6) and (8)) and normalizing to the known k at p = 1.0 gives
 The above discussion involves an artificial system for which p – pc is known. In contrast, a physical system's proximity to the percolation threshold is not generally known. In this case we combine the several unknowns, defining
which allows us to treat 0 as our second fitting parameter (after χ). The local diffusion coefficient is then simply given as


Assuming that you mean "-Wunreachable-code" rather than "-Dunreachable-code", the answer is fairly simple (though hard to track down.)
The problem is that the configure script is generating something like:
The combination of "-Werror" and "-Wunreachable-code" to GCC will cause the "return 0" in the generated code to be unreachable (GCC recognizes exit() as not returning), thus produces a warning, which (due to "-Werror") is an error, hence the test fails because the compile fails.
exit (malloc (0) ? 0 : 1);
If you're feeling ambitious, and insist on using the combination of "-Werror" and "-Wunreachable-code", you could go to /usr/lib/share/autoconf/autoconf (or wherever you have the autoconf M4 files), and edit the file autoconf.m4f; search for the line that reads:
and replace it with something like:
[exit (malloc (0) ? 0 : 1);])],
This should provide an execution path to the "return 0;", thus get rid of the unreachable-code warning, which should then produce the correct result. Test it, of course, as I may have screwed the code fragment up. This only fixes this instance of unreachable code in autoconf's generated tests, so my recommendation is that you don't use "-Wunreachable-code" in distributed apps, just in development.
[if (malloc(0) == 0) exit(1);])],
I hope this helps.


Today,I will learn you how to create authentication with breeze in laravel. We will show example of laravel authentication with breeze. You can easy to make authentication with breeze in laravel.we will give example of laravel login and registration using breeze. We will use laravel 8 breeze tutorial. I’m going to show you about laravel breeze bootstrap. we will help you to give example of laravel install breeze using auth. you will do the following things for auth using breeze in laravel.
Breeze allows you to implement a minimal furthermore an easy starting point for creating a Laravel application with authentication. We will use the breeze auth to implement default login, register, reset the password, forget password, email verification, and two-factor authentication blade views and controller file.
Here, I will give you full example for simply authentication with breeze in laravel bellow.
Step 1 : Install Laravel 8 Application
We are going from scratch, So we require to get fresh Laravel application using bellow command, So open your terminal OR command prompt and run bellow command:
composer create-project --prefer-dist laravel/laravel blog
Step 2 :Installing Breezes Package
Now In this step, install laravel/breeze package in laravel 8 app via following command.
composer require laravel/breeze --dev
After you have to install laravel breeze for simple auth scaffolding. so let's run bellow command:
php artisan breeze:install
Breeze scaffolding installed successfully. Please execute the "npm install && npm run dev" command to build your assets.
Next let's run bellow command:
npm install && npm run dev
We will generate css and js min files.
Now do everything successfully you have following files and code.
Let's see bellow applications Screenshots:
It will help you.....


I have a question about something that has puzzled me. I did this
on my program because it was how I saw it done. I was wondering if
someone could explain why it is done this way and if I would do this for
I used the following code. What does the ".getSource()" do? Is that
what registers when someone clicks the button? How would this format
change if I was adding data entered into a text field? Any help is much
public void actionPerformed(ActionEvent e)
if (e.getSource() == b)
if (click == 1)
b.setText("I've been clicked!");
b.setText("I've been clicked " + click + " times!");
e.getResource() method is to capture the resource which invokes actionPerformed method.
We can consider the following situation to understand why e.getResource method is useful.
Suppose I have 4 buttons, the actions of each button when pressed are ...


Welcome to the official Join2 Games website!
If you are new and don't know us yet, please take a look at our games.
Thank you for coming!
Check out our latest free game! Already available for Windows Phone.
Very addictive and funny platformer game exclusive for Windows Phone.
Our best rated game. Simple and fun, perfect for those waiting moments! Available for iPhone and Windows Phone.
Discover all our retro-pixelated style games!
By A Web Design


Developer Strangelove or How I Learned to Stop Worrying and Love the Waterfall Model
Everyone loves to hate the Waterfall Model (WM) and extoll the virtues of modern development methodologies. But while people are rolling their eyes at the mere mention of the WM, they forget that it was one of the first attempts at a systematic approach to complex system development. Few first attempts turn out to be the best, but all first attempts teach us something. As such, the WM contains pearls of wisdom that should not be ignored.
Figure 1: The Venerable Waterfall Model
For the uninitiated, the WM starts with requirements. Requirements describe what the system or software will accomplish in structured natural language. An overly simple example might be: “If signal A is true, the system shall light the green LED.” A complex system could have tens or even hundreds of thousands of requirements. A modern aircraft has millions. The next step is architecture and design. Here the requirements are analyzed and categorized to guide the system or software architecture design. The result is your typical flowchart-like diagram with boxes representing functionality and connectors for interfaces. Implementation is next. The developers implement the hardware and/or software needed to fulfill requirements within the boundaries provided by the architecture. Finally, you test the implementation. Easy peasy.
There are three benefits to the WM: 1) a systematic approach 2) that is easy to understand and 3) recognizes that details increase over time. First, having a systematic approach to anything is a good idea. For system and software design, a systematic approach guides developers along a logical path of development, provides oversight for project progress, and improves reproducibility. Second, the WM is very easy to understand. This benefit should not be scoffed at; simplicity is its own reward. Third, the WM is a top-down approach that starts at a high-level of understanding and specification and works its way down, increasing details at each level, until the final product is realized and verified. This might seem obvious now but that is only because the WM engrained it in the minds of developers over the last 50+ years.
Over the years the WM has been the victim of oversimplifications and misunderstandings. For instance, one misunderstanding is that the next phase could only start after the previous phase finished. The WM in no way suggests this, in fact pictures of the WM always show the phases overlapping. That’s not to say there aren’t legitimate problems with the WM. Although it rarely happened in practice, a major downfall of the WM is that testing is shown to happen only at the end. This implies you’ve gone through months or even years of work before you run the first test. No one really did this, but it’s how the model was presented. Another problem is that the WM doesn’t contain any notion of feedback loops. It’s commonly accepted these days that refinement is done after feedback from subsequent phases and that changes from outside forces necessitate rework. But the WM is presented in a linear fashion which ignores these inevitable loops.
So now you’re asking yourself: why would a system/software engineer with 20 years’ experience in safety-critical industries put up a spirited defense of the old worn-out WM? Answer: because the Waterfall Model set the stage for the V-Model.
Tune in next time, when I describe WM’s spiritual successor, the V-Model.
Requirements are the key to success. Some customers have great requirements, and some have crummy requirements. Crummy engineers have a chance of muddling through if the requirements are good and understood. Good engineers with a good model will stumble (or grumble) with crummy requirements.
The WM allows for loops, but try convincing managers to allocate time and staff for the looping. The enlightened ones might add in a little.
An engineer with some understanding of the product (system requirements, experience, napkin, etc.) can start working on tests even before the requirements are complete. I made the mistake of saying out loud in a meeting that I was working on tests before software requirement completion, and was greeted with stares as though I had grown a third eye.
As a requirements engineer, I whole-heartedly agree! Requirements will be an interesting challenge for the EB project (see subsequent posts) since we don’t really have developers in the traditional sense. I hope all is well at Astro. I miss you and the old crew. 🙂
Just read you posts, great reads.
Working for over 15 yrs in automotive and today I (again) had to explain, that although we want to be “agile”, we need some product reqs writen down and a process to get the missing ones! Having user stories in Jira is not enough to be certain we are going to hit what our customer (actually thinks he/she) needs …
Keep at it, looking forward to new posts!
Sorry for the anonymity, I am kind of like that way :)!


FYI we have developed a new module ServiceAPI that allows to get access to user’s data in an emonCMS installation by providing a master apikey (aka service_apikey)
and the username or email address of the user.
Our user case is to allow our members to access their MyHomeEnergyPlanner data from our dashboard (in a complete different web app). This way we don’t need to know the user write or read apikeys.
The service_apikey can be sent in the query string of the URL or as a POST field (recommended)
So to access data this way you could do a curl to something like:


Salem gave you $$$n$$$ sticks with integer positive lengths $$$a_1, a_2, \ldots, a_n$$$.

For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from $$$a$$$ to $$$b$$$ is $$$|a - b|$$$, where $$$|x|$$$ means the absolute value of $$$x$$$.

A stick length $$$a_i$$$ is called almost good for some integer $$$t$$$ if $$$|a_i - t| \le 1$$$.

Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer $$$t$$$ and the total cost of changing is minimum possible. The value of $$$t$$$ is not fixed in advance and you can choose it as any positive integer.

As an answer, print the value of $$$t$$$ and the minimum cost. If there are multiple optimal choices for $$$t$$$, print any of them.


To celebrate his recovery, k1o0n has baked an enormous $$$n$$$ metres long potato casserole.

Turns out, Noobish_Monk just can't stand potatoes, so he decided to ruin k1o0n's meal. He has cut it into $$$k$$$ pieces, of lengths $$$a_1, a_2, \dots, a_k$$$ meters.

k1o0n wasn't keen on that. Luckily, everything can be fixed. In order to do that, k1o0n can do one of the following operations:

- Pick a piece with length $$$a_i \ge 2$$$ and divide it into two pieces with lengths $$$1$$$ and $$$a_i - 1$$$. As a result, the number of pieces will increase by $$$1$$$;
- Pick a slice $$$a_i$$$ and another slice with length $$$a_j=1$$$ ($$$i \ne j$$$) and merge them into one piece with length $$$a_i+1$$$. As a result, the number of pieces will decrease by $$$1$$$.

Help k1o0n to find the minimum number of operations he needs to do in order to merge the casserole into one piece with length $$$n$$$.

For example, if $$$n=5$$$, $$$k=2$$$ and $$$a = [3, 2]$$$, it is optimal to do the following:

1. Divide the piece with length $$$2$$$ into two pieces with lengths $$$2-1=1$$$ and $$$1$$$, as a result $$$a = [3, 1, 1]$$$.
2. Merge the piece with length $$$3$$$ and the piece with length $$$1$$$, as a result $$$a = [4, 1]$$$.
3. Merge the piece with length $$$4$$$ and the piece with length $$$1$$$, as a result $$$a = [5]$$$.


Talk in English - US at Madison PHP Conference 2018
View Slides: https://github.com/galieth/2018_madisonphp_talks/tree/master/Gutenberg
Short URL: https://joind.in/talk/5d414 (QR-Code (opens in new window))
Gutenberg is WordPress's newest method for creating pages. Come and hear about how it will change how you create content, and how you as a programmer can make it easier for editors to create pages.


// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// This file declares a class that contains various method related to branding.

#ifndef CHROME_INSTALLER_UTIL_BROWSER_DISTRIBUTION_H_
#define CHROME_INSTALLER_UTIL_BROWSER_DISTRIBUTION_H_

#include <string>

#include "base/basictypes.h"
#include "base/files/file_path.h"
#include "base/strings/string16.h"
#include "base/version.h"
#include "chrome/installer/util/util_constants.h"

#if defined(OS_WIN)
#include <windows.h>  // NOLINT
#endif

class BrowserDistribution {
 public:
  enum Type {
    CHROME_BROWSER,
    CHROME_FRAME,
    CHROME_BINARIES,
    CHROME_APP_HOST,
    NUM_TYPES
  };

  virtual ~BrowserDistribution() {}

  static BrowserDistribution* GetDistribution();

  static BrowserDistribution* GetSpecificDistribution(Type type);

  Type GetType() const { return type_; }

  virtual void DoPostUninstallOperations(const Version& version,
                                         const base::FilePath& local_data_path,
                                         const string16& distribution_data);

  // Returns the GUID to be used when registering for Active Setup.
  virtual string16 GetActiveSetupGuid();

  virtual string16 GetAppGuid();

  // Returns the unsuffixed application name of this program.
  // This is the base of the name registered with Default Programs on Windows.
  // IMPORTANT: This should only be called by the installer which needs to make
  // decisions on the suffixing of the upcoming install, not by external callers
  // at run-time.
  virtual string16 GetBaseAppName();

  // Returns the localized name of the program.
  virtual string16 GetAppShortCutName();

  virtual string16 GetAlternateApplicationName();

  // Returns the unsuffixed appid of this program.
  // The AppUserModelId is a property of Windows programs.
  // IMPORTANT: This should only be called by ShellUtil::GetAppId as the appid
  // should be suffixed in all scenarios.
  virtual string16 GetBaseAppId();

  virtual string16 GetInstallSubDir();

  virtual string16 GetPublisherName();

  virtual string16 GetAppDescription();

  virtual string16 GetLongAppDescription();

  virtual std::string GetSafeBrowsingName();

  virtual string16 GetStateKey();

  virtual string16 GetStateMediumKey();

  virtual std::string GetNetworkStatsServer() const;

  virtual std::string GetHttpPipeliningTestServer() const;

#if defined(OS_WIN)
  virtual string16 GetDistributionData(HKEY root_key);
#endif

  virtual string16 GetUninstallLinkName();

  virtual string16 GetUninstallRegPath();

  virtual string16 GetVersionKey();

  virtual bool CanSetAsDefault();

  virtual bool CanCreateDesktopShortcuts();

  // Returns the executable filename (not path) that contains the product icon.
  virtual string16 GetIconFilename();

  // Returns the index of the icon for the product, inside the file specified by
  // GetIconFilename().
  virtual int GetIconIndex();

  virtual bool GetChromeChannel(string16* channel);

  // Returns true if this distribution includes a DelegateExecute verb handler,
  // and provides the CommandExecuteImpl class UUID if |handler_class_uuid| is
  // non-NULL.
  virtual bool GetCommandExecuteImplClsid(string16* handler_class_uuid);

  // Returns true if this distribution uses app_host.exe to run platform apps.
  virtual bool AppHostIsSupported();

  virtual void UpdateInstallStatus(bool system_install,
      installer::ArchiveType archive_type,
      installer::InstallStatus install_status);

  // Returns true if this distribution should set the Omaha experiment_labels
  // registry value.
  virtual bool ShouldSetExperimentLabels();

  virtual bool HasUserExperiments();

 protected:
  explicit BrowserDistribution(Type type);

  template<class DistributionClass>
  static BrowserDistribution* GetOrCreateBrowserDistribution(
      BrowserDistribution** dist);

  const Type type_;

 private:
  BrowserDistribution();

  DISALLOW_COPY_AND_ASSIGN(BrowserDistribution);
};

#endif  // CHROME_INSTALLER_UTIL_BROWSER_DISTRIBUTION_H_


I am after creating a Blog and wiki functionality in Websphere Portal. I understand that blogs and wiki's can be created even with Quickr which we are already using but since we only have licence for Quickr for Lotus Domino, we cannot incorporate the Blogs in Webpshere portal as portlets and just have to give as url's.
I am actually after creating Blogs using Portlet factory/WCM in Websphere Portal 6.1 so that they can be incorporated in Websphre portal. So could some one suggest a approch to create Blogs, wiki's using rtlet factory/Lotus Web Content Management.
Re: Blogs and wiki functionality2009-12-16T20:56:27ZThis is the accepted answer. This is the accepted answer.From what I know about the WCM builder, it only allows you to consume WCM content.
You might want to post into the WebSphere Portlet Factory Best Practices database, which gets a lot more traffic than this database.
sabIBMDevWork 0600012RYD1 Post
Re: Blogs and wiki functionality2010-01-27T15:49:02ZThis is the accepted answer. This is the accepted answer.In Websphere Portal 6.1.5 a set of preinstalled Web content libraries are supplied to allow you to add blog and wiki features to your Web sites.
Re: Blogs and wiki functionality2010-01-27T15:53:12ZThis is the accepted answer. This is the accepted answer.
- sabIBMDevWork 0600012RYD
I tried with this but i have some issues as posted in the new forum


- Is Computer Engineering hard to study?
- Is computer engineering in demand?
- Is Computer Engineering a good career?
- What does it take to be a computer engineer?
- Which is harder electrical or computer engineering?
- Does computer engineering require math?
- Which is better IT or computer engineering?
- Who gets paid more computer science or computer engineering?
- Which is harder engineering or computer science?
For me, the answer is that Computer Engineering is very hard.
I would prefer Computer Science or Civil Engineering because they appeal to my particular set of problem solving skills in terms of logic and structure.
Your answer will be different.
Computer Engineering is a very interesting field (even for me).
Is Computer Engineering hard to study?
Electrical engineering is not the hardest engineering discipline. Computer Engineering is more or less the same as Electrical, but with a few less analog classes, and a few more computer science and digital classes. Pure Computer Science (CS) is not an engineering discipline. It is a lot more like Math.
Is computer engineering in demand?
Employment of computer hardware engineers is projected to grow 6 percent from 2018 to 2028, about as fast as the average for all occupations. A limited number of engineers will be needed to meet the demand for new computer hardware because more technological innovation takes place with software than with hardware.
Is Computer Engineering a good career?
While there are many different jobs within the field of computer engineering, there are several commonalities among them that make it an excellent choice for the right person. The benefits of computer engineering as a career include great pay, job security and an environment of change and innovation.
What does it take to be a computer engineer?
Computer engineers typically need a bachelor’s degree in computer engineering, computer science, or software engineering to be able to work in the field, according to the BLS (BLS, Dec. 2015). Students also may be able to find schools that offer a combined bachelor’s and master’s degree through five-year programs.
Which is harder electrical or computer engineering?
Electrical Engineering relies heavily on complicated nonlinear math where exact answers are difficult to come by. Finally, Computer Engineering works with more discrete math and logic design requiring you to design solutions that can solve a myriad of problems, plus more language learning than the others.
Does computer engineering require math?
A computer engineering degree requires numerous math courses. At minimum, students should expect three different calculus courses plus differential equations. Mathematical modeling, probability, cryptography and statistics may also be in the degree plan.
Which is better IT or computer engineering?
Computer science focuses on the basics of computing, including, algorithms, programming languages, artificial intelligence and hardware design. Computer engineering is focused more on the designing and developing of computer systems and how the software interacts with the hardware.
Who gets paid more computer science or computer engineering?
Computer science majors can earn 40 percent more than other college majors, and all occupations in science, technology, engineering, and mathematics (STEM) pay more than non- STEM careers by 12-30 percent across all education levels.
Which is harder engineering or computer science?
Both are tough, but with computer science you mainly focus on mathematics and computer related problems. In engineering you have to go through a lot of math and lot of science and physics and then more science depending on which type of engineering you do. If you don’t like math, then engineering is harder.


Fishingprince loves trees. A tree is a connected undirected graph without cycles.

Fishingprince has a tree of $$$n$$$ vertices. The vertices are numbered $$$1$$$ through $$$n$$$. Let $$$d(x,y)$$$ denote the shortest distance on the tree from vertex $$$x$$$ to vertex $$$y$$$, assuming that the length of each edge is $$$1$$$.

However, the tree was lost in an accident. Fortunately, Fishingprince still remembers some information about the tree. More specifically, for every triple of integers $$$x,y,z$$$ ($$$1\le x<y\le n$$$, $$$1\le z\le n$$$) he remembers whether $$$d(x,z)=d(y,z)$$$ or not.

Help him recover the structure of the tree, or report that no tree satisfying the constraints exists.


We’re happy to announce our next release candidate, Druid 0.12.2-rc1!
Druid 0.12.2 is a non-ASF release.
It contains stability improvements and bug fixes from 13 contributors. Major improvements include more stable data ingestion especially for Kafka indexing service, more stable segment management, and bug fixes in querying and result caching.
Everyone in the community is invited to help out with the upcoming release by downloading this candidate and evaluating it.
Draft release notes are at:
Documentation for this release candidate is at:
You can download the release candidate here:
Please file GitHub issues if you find any problems:
Thanks everyone who contributed!


You are given a multiset of n integers. You should select exactly k of them in a such way that the difference between any two of them is divisible by m, or tell that it is impossible.

Numbers can be repeated in the original multiset and in the multiset of selected numbers, but number of occurrences of any number in multiset of selected numbers should not exceed the number of its occurrences in the original multiset.


These days Arkady works as an air traffic controller at a large airport. He controls a runway which is usually used for landings only. Thus, he has a schedule of planes that are landing in the nearest future, each landing lasts $$$1$$$ minute.

He was asked to insert one takeoff in the schedule. The takeoff takes $$$1$$$ minute itself, but for safety reasons there should be a time space between the takeoff and any landing of at least $$$s$$$ minutes from both sides.

Find the earliest time when Arkady can insert the takeoff.


Hi guys and girls,
I have created a survey as part of my work experience project in which I was tasked to gather information about how technology and education relate together. The data gathered in this survey will be used in a report to present my findings.
I will be asking three sets of questions which will aim to gather important information which will impact on your future education and career!
These questions will ask you about your school experiences and also your expectations of university.
All data collected in this survey will remain anonymous and will not be shown to anyone apart from those involved in the project.
Have you done any of these?


/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2009  Free Software Foundation, Inc.
 *
 *  GRUB is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  GRUB is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <grub/types.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/err.h>
#include <grub/dl.h>
#include <grub/device.h>
#include <grub/disk.h>
#include <grub/partition.h>
#include <grub/gpt_partition.h>
#include <grub/net.h>
#include <grub/fs.h>
#include <grub/file.h>
#include <grub/misc.h>
#include <grub/env.h>
#include <grub/extcmd.h>
#include <grub/i18n.h>
#include <grub/i386/pc/boot.h>

GRUB_MOD_LICENSE ("GPLv3+");

static const struct grub_arg_option options[] =
  {
    {"set",             's', 0,
     N_("Set a variable to return value."), N_("VARNAME"), ARG_TYPE_STRING},
    /* TRANSLATORS: It's a driver that is currently in use to access
       the diven disk.  */
    {"driver",		'd', 0, N_("Determine driver."), 0, 0},
    {"partmap",		'p', 0, N_("Determine partition map type."), 0, 0},
    {"fs",		'f', 0, N_("Determine filesystem type."), 0, 0},
    {"fs-uuid",		'u', 0, N_("Determine filesystem UUID."), 0, 0},
    {"label",		'l', 0, N_("Determine filesystem label."), 0, 0},
    {"part-uuid",	0,   0, N_("Determine partition UUID."), 0, 0},
    {0, 0, 0, 0, 0, 0}
  };

static grub_err_t
grub_cmd_probe (grub_extcmd_context_t ctxt, int argc, char **args)
{
  struct grub_arg_list *state = ctxt->state;
  grub_device_t dev;
  grub_fs_t fs;
  char *ptr;
  grub_err_t err;

  if (argc < 1)
    return grub_error (GRUB_ERR_BAD_ARGUMENT, "device name required");

  ptr = args[0] + grub_strlen (args[0]) - 1;
  if (args[0][0] == '(' && *ptr == ')')
    {
      *ptr = 0;
      dev = grub_device_open (args[0] + 1);
      *ptr = ')';
    }
  else
    dev = grub_device_open (args[0]);
  if (! dev)
    return grub_errno;

  if (state[1].set)
    {
      const char *val = "none";
      if (dev->net)
	val = dev->net->protocol->name;
      if (dev->disk)
	val = dev->disk->dev->name;
      if (state[0].set)
	grub_env_set (state[0].arg, val);
      else
	grub_printf ("%s", val);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  if (state[2].set)
    {
      const char *val = "none";
      if (dev->disk && dev->disk->partition)
	val = dev->disk->partition->partmap->name;
      if (state[0].set)
	grub_env_set (state[0].arg, val);
      else
	grub_printf ("%s", val);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  if (state[6].set)
    {
      /* AAAABBBB-CCCC-DDDD-EEEE-FFFFFFFFFFFF + null terminator */
      char val[37] = "none";
      if (dev->disk && dev->disk->partition)
	{
	  struct grub_partition *p = dev->disk->partition;
	  grub_disk_t disk = grub_disk_open(dev->disk->name);

	  if (!disk)
	    {
	      grub_device_close (dev);
	      return grub_errno;
	    }

	  if (grub_strcmp(dev->disk->partition->partmap->name, "gpt") == 0)
	    {
	      struct grub_gpt_partentry entry;
	      grub_gpt_part_guid_t *guid;

	      if (grub_disk_read(disk, p->offset, p->index, sizeof(entry), &entry))
		return grub_errno;
	      guid = &entry.guid;
	      grub_snprintf (val, sizeof(val),
			     "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
			     grub_le_to_cpu32 (guid->data1),
			     grub_le_to_cpu16 (guid->data2),
			     grub_le_to_cpu16 (guid->data3),
			     guid->data4[0], guid->data4[1], guid->data4[2],
			     guid->data4[3], guid->data4[4], guid->data4[5],
			     guid->data4[6], guid->data4[7]);
	    }
	  else if (grub_strcmp(dev->disk->partition->partmap->name, "msdos") == 0)
	    {
	      grub_uint32_t nt_disk_sig;

	      if (grub_disk_read(disk, 0, GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
				 sizeof(nt_disk_sig), &nt_disk_sig) == 0)
		grub_snprintf (val, sizeof(val), "%08x-%02x",
			       grub_le_to_cpu32(nt_disk_sig), 1 + p->number);
	    }
	  grub_disk_close(disk);
	}
      if (state[0].set)
	grub_env_set (state[0].arg, val);
      else
	grub_printf ("%s", val);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  fs = grub_fs_probe (dev);
  if (! fs)
    return grub_errno;
  if (state[3].set)
    {
      if (state[0].set)
	grub_env_set (state[0].arg, fs->name);
      else
	grub_printf ("%s", fs->name);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  if (state[4].set)
    {
      char *uuid;
      if (! fs->fs_uuid)
	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
			   N_("%s does not support UUIDs"), fs->name);
      err = fs->fs_uuid (dev, &uuid);
      if (err)
	return err;
      if (! uuid)
	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
			   N_("%s does not support UUIDs"), fs->name);

      if (state[0].set)
	grub_env_set (state[0].arg, uuid);
      else
	grub_printf ("%s", uuid);
      grub_free (uuid);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  if (state[5].set)
    {
      char *label;
      if (! fs->fs_label)
	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
			   N_("filesystem `%s' does not support labels"),
			   fs->name);
      err = fs->fs_label (dev, &label);
      if (err)
	return err;
      if (! label)
	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
			   N_("filesystem `%s' does not support labels"),
			   fs->name);

      if (state[0].set)
	grub_env_set (state[0].arg, label);
      else
	grub_printf ("%s", label);
      grub_free (label);
      grub_device_close (dev);
      return GRUB_ERR_NONE;
    }
  grub_device_close (dev);
  return grub_error (GRUB_ERR_BAD_ARGUMENT, "unrecognised target");
}

static grub_extcmd_t cmd;

GRUB_MOD_INIT (probe)
{
  cmd = grub_register_extcmd ("probe", grub_cmd_probe, 0, N_("DEVICE"),
			      N_("Retrieve device info."), options);
}

GRUB_MOD_FINI (probe)
{
  grub_unregister_extcmd (cmd);
}


Yarik is a big fan of many kinds of music. But Yarik loves not only listening to music but also writing it. He likes electronic music most of all, so he has created his own system of music notes, which, in his opinion, is best for it.

Since Yarik also likes informatics, in his system notes are denoted by integers of $$$2^k$$$, where $$$k \ge 1$$$ — a positive integer. But, as you know, you can't use just notes to write music, so Yarik uses combinations of two notes. The combination of two notes $$$(a, b)$$$, where $$$a = 2^k$$$ and $$$b = 2^l$$$, he denotes by the integer $$$a^b$$$.

For example, if $$$a = 8 = 2^3$$$, $$$b = 4 = 2^2$$$, then the combination $$$(a, b)$$$ is denoted by the integer $$$a^b = 8^4 = 4096$$$. Note that different combinations can have the same notation, e.g., the combination $$$(64, 2)$$$ is also denoted by the integer $$$4096 = 64^2$$$.

Yarik has already chosen $$$n$$$ notes that he wants to use in his new melody. However, since their integers can be very large, he has written them down as an array $$$a$$$ of length $$$n$$$, then the note $$$i$$$ is $$$b_i = 2^{a_i}$$$. The integers in array $$$a$$$ can be repeated.

The melody will consist of several combinations of two notes. Yarik was wondering how many pairs of notes $$$b_i, b_j$$$ $$$(i < j)$$$ exist such that the combination $$$(b_i, b_j)$$$ is equal to the combination $$$(b_j, b_i)$$$. In other words, he wants to count the number of pairs $$$(i, j)$$$ $$$(i < j)$$$ such that $$$b_i^{b_j} = b_j^{b_i}$$$. Help him find the number of such pairs.


Vlad remembered that he had a series of $$$n$$$ tiles and a number $$$k$$$. The tiles were numbered from left to right, and the $$$i$$$-th tile had colour $$$c_i$$$.

If you stand on the first tile and start jumping any number of tiles right, you can get a path of length $$$p$$$. The length of the path is the number of tiles you stood on.

Vlad wants to see if it is possible to get a path of length $$$p$$$ such that:

- it ends at tile with index $$$n$$$;
- $$$p$$$ is divisible by $$$k$$$
- the path is divided into blocks of length exactly $$$k$$$ each;
- tiles in each block have the same colour, the colors in adjacent blocks are not necessarily different.

For example, let $$$n = 14$$$, $$$k = 3$$$.

The colours of the tiles are contained in the array $$$c$$$ = [$$$\color{red}{1}, \color{violet}{2}, \color{red}{1}, \color{red}{1}, \color{gray}{7}, \color{orange}{5}, \color{green}{3}, \color{green}{3}, \color{red}{1}, \color{green}{3}, \color{blue}{4}, \color{blue}{4}, \color{violet}{2}, \color{blue}{4}$$$]. Then we can construct a path of length $$$6$$$ consisting of $$$2$$$ blocks:

$$$\color{red}{c_1} \rightarrow \color{red}{c_3} \rightarrow \color{red}{c_4} \rightarrow \color{blue}{c_{11}} \rightarrow \color{blue}{c_{12}} \rightarrow \color{blue}{c_{14}}$$$

All tiles from the $$$1$$$-st block will have colour $$$\color{red}{\textbf{1}}$$$, from the $$$2$$$-nd block will have colour $$$\color{blue}{\textbf{4}}$$$.

It is also possible to construct a path of length $$$9$$$ in this example, in which all tiles from the $$$1$$$-st block will have colour $$$\color{red}{\textbf{1}}$$$, from the $$$2$$$-nd block will have colour $$$\color{green}{\textbf{3}}$$$, and from the $$$3$$$-rd block will have colour $$$\color{blue}{\textbf{4}}$$$.


Any experience with either of these two online vendors. Elegant Audio is selling the speakers I like at deep discounted prices. I could buy a much higher quality model speaker given their discounted pricing. HIDEF is selling through 'Amazon but still wanted to check to see if others had any experience dealing with them? Should i steer clear of either one or both?


I'm using getrusage to get the usertime and systemtime, but sometimes the times returned are negative -->
user time: 1313366639 microseconds
system time: -1547562616 microseconds
I'm not sure I've understood getrusage correctly, so I'm posting my code in hope of getting a few tips on how to avoid the negative numbers... :o)
The output is supposed to be in microseconds, and I read that the output from tv_sec + tv_usec can be both in microseconds and seconds... How do I know which one I get?
struct rusage ru; struct timeval tim; getrusage(RUSAGE_SELF, &ru); tim=ru.ru_utime; double sutime = (double)tim.tv_sec + (double)tim.tv_usec / 1000000.0; printf("SELF:\n"); printf(" user time: %d microseconds\n", sutime); tim=ru.ru_stime; double sstime = (double)tim.tv_sec + (double)tim.tv_usec / 1000000.0; printf(" system time: %d microseconds\n", sstime);


Elaphe carinata is a large snake with total length up to 240 cm (94 in). The other common names "stink snake" or "stinking goddess" refer to this species' highly developed post-anal glands which, when the snake is picked up, are frequently emptied, with a very strong, bad odour.
Elaphe carinata is an active, predatory snake that eats everything from beetles to birds to snakes, with particular preference for the latter.
The common name of "King ratsnake" refers to its habit of eating other snakes, including venomous species such as the Chinese cobra and the sharp-nosed viper. It suffocates its prey by constriction, similar to the hunting technique of boas and pythons. It also preys on rodents and other small animals.
Distribution: China, North Vietnam, Taiwan, Japan (Ryukyu Islands).
- Hans Breuer & William Christopher Murphy (2009-2010). "Elaphe carinata". Snakes of Taiwan. Retrieved 15 October 2012.
- Elaphe carinata at the Reptarium.cz Reptile Database. Accessed 15 October 2012.
- Zhou, Z.; Jiang, Z. (2004). "International trade status and crisis for snake species in China". Conservation Biology 18 (5): 1386–1394. doi:10.1111/j.1523-1739.2004.00251.x.
|Wikimedia Commons has media related to Elaphe.|
|Wikispecies has information related to: Elaphe carinata|
|This Colubrids article is a stub. You can help Wikipedia by expanding it.|


You are given a bracket sequence $$$s$$$ of length $$$n$$$, where $$$n$$$ is even (divisible by two). The string $$$s$$$ consists of $$$\frac{n}{2}$$$ opening brackets '(' and $$$\frac{n}{2}$$$ closing brackets ')'.

In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index $$$i$$$, remove the $$$i$$$-th character of $$$s$$$ and insert it before or after all remaining characters of $$$s$$$).

Your task is to find the minimum number of moves required to obtain regular bracket sequence from $$$s$$$. It can be proved that the answer always exists under the given constraints.

Recall what the regular bracket sequence is:

- "()" is regular bracket sequence;
- if $$$s$$$ is regular bracket sequence then "(" + $$$s$$$ + ")" is regular bracket sequence;
- if $$$s$$$ and $$$t$$$ are regular bracket sequences then $$$s$$$ + $$$t$$$ is regular bracket sequence.

For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.

You have to answer $$$t$$$ independent test cases.


How to configure Microsoft IAS for use with the Symantec LAN Enforcer
Last Updated March 16, 2012
This article covers the steps required for configuring the Microsoft Internet Authentication Service (IAS) for use with the Symantec LAN Enforcer.
The Symantec LAN Enforcer in Symantec Network Access Control can forward RADIUS requests from an 802.1x enabled switch for optional user authentication. This configuration is called Basic Mode - for details please see the following article:
The RADIUS user authentication in LAN Enforcer Basic mode can be provided by IAS. The steps below will help enable this configuration in PEAP (Protected EAP) mode.
In the Symantec Endpoint Protection Manager (SEPM) console:
Configure the Client Group supplicant settings:
Navigate to Policies - General Settings - Security Settings.
Check the "Enable 802.1x authentication" option, but do not check "Use Symantec Transparent Mode".
Configure the LAN Enforcer to use the IAS as RADIUS server:
Navigate to Admin - Servers.
Select Edit Group Properties for the LAN Enforcer group.
On the RADIUS Server Group tab create a new group with the IP address of the IAS server and a shared secret.
On the Switch tab edit the Switch Policy and select the new RADIUS Server Group in the dropdown list.
In the Active Directory Users and Computers MMC snapin:
Allow Remote Access for the user account that is to be authenticated via the LAN Enforcer and IAS server.
In the user account properties dialog, select the Dial-in tab and pick the option to allow access under Remote Access Permissions.
Create a certificate to use for PEAP:
Make sure Certificate Services are installed on the server (in Control Panel - add/remove Windows components).
Create a new certificate on http://localhost/certsrv/ following the steps in Microsoft article KB871222.
Visit http://localhost/certsrv/ and click Request a certificate.
Select Advanced certificate request.
Select Create and submit a request to this CA.
Select Microsoft RSA SChannel Cryptographic Provider in the CSP dropdown.
Check the Store Certificate in the local computer certificate store check box.
Leave the default options of 1024 for Key Size, and "Create a new key set" and "Automatic container name" selected.
Enter Identifying Information as appropriate.
In the Microsoft Internet Authentication Service (IAS) MMC snapin:
Configure a new RADIUS Client using the LAN Enforcer IP address:
Under RADIUS Clients, select New RADIUS Client and enter the LAN Enforcer IP address.
Press Next, and fill in the same shared secret entered in the LAN Enforcer group policy RADIUS Server Group created earlier.
Create a new Remote Access Policy:
Under Remote Access Policies, select New Remote Access Policy.
Using either the wizard option or the custom policy option, create policy conditions and a profile to control network access.
Use conditions matching the client requests (for example "Ethernet" or "Domain Users" for an initial test granting access).
For the Profile, select Protected EAP (PEAP) as the EAP type.
Further edit the Protected EAP (PEAP) method, and select the certificate created earlier from the dropdown list.
To access the certificate selection after saving the policy (or if not using the wizard):
Click Edit Profile.
Select the Authentication tab.
Click EAP Methods.
Click Add and select PEAP if it is not in the EAP types list already.
Select PEAP and click Edit.
Pick the correct certificate from the dropdown.
If any part of the configuration is missing the IAS server will write an entry to the standard Windows System Event Log. The event log entries contain a text description with useful hints to which step has not been configured correctly (such as "invalid RADIUS client IP address" if the LAN Enforcer has not been entered as a trusted client of the IAS).
Capturing the traffic and filtering on the RADIUS traffic will also indicate if the requests were received on the server and if any reply was sent. When capturing on the client side a useful filter would be EAP to view the communication between the switch and the local supplicant.
The IAS server listens on the RADIUS 1812 UDP port, which is also used by the SEPM. If both are installed on the same machine the IAS needs to be configured to use a separate port.
It is recommended that the less complex Transparent mode is configured first with the LAN Enforcer, before the environment is changed to Basic mode with user authentication.
Imported Document ID: HOWTO74612
Subscribing will provide email updates when this Article is updated. Login is required to Subscribe


Can some smart programmers stop the if-then snow loop soon? The Northeast gets a double shot on Monday and Tuesday. The snow in Texas is gone but it left behind an impressive amount of damage. Under the snowmelt we found some newsbits, so enjoy.
Seems like the weather demands yet more attention. At the time of this writing on February 15, Dallas is six degrees colder than Anchorage, Alaska. Houston is only one degree warmer than the Alaskan city 4,132 miles to the northwest. New York City is 23 degrees warmer than Dallas.


We love checking out Nintendo Switch accessories, cases, controllers, anything at all really and luckily TOMTOC were kind enough to send over their Slim case for the Nintendo Switch OLED for us to review!
This is a super thin hardcase with joystick protection, supposedly safeguarded against drops & shocks, is water repellent, has 10 game card case slots and YKK zips! So, what do I think of it? Is this the best Nintendo Switch OLED slim case? Let’s find out!
Purchase the TomToc Slim here:
Welcome to 128KB a channel dedicated to bringing you the latest videos about gaming, console accessories, retro games, tech and more!
🎮 Gaming News & Playstation Videos: https://www.youtube.com/128KBNews
Become A Member
Want to support us? Join our YouTube Memberships https://www.youtube.com/channel/UCanRIbY9MBoJIWgC7YL2sMA/join
Gear We Use In Our Videos
Podcast Camera: https://geni.us/Mew05R
Main Camera: https://geni.us/KcHdjq5
Podcast Lens: https://geni.us/nu1t
Podcast Mics: https://geni.us/tAdjb0
Mic Stands: https://geni.us/2hE4C
Desk Of Jingle Glory: https://geni.us/XH1R0A
Streaming Mics: https://geni.us/Uan6tfc
Streaming Camera: https://geni.us/d01j
Artlist Get 2 Months Free: https://bit.ly/2RVQGig
Twitch Music Library: https://120fps.co.uk/product/copyright-free-music-library/
Sign Up To The Newsletter: http://eepurl.com/hYjJXf
Affiliate Links Notice
Some of these links are affiliate links, which means at no extra cost to you, we will make a small commission if you click them and make a purchase.
🚩 If you’re a YouTuber, you have to check out TubeBuddy. It’s an amazing tool!


#include<stdlib.h>
#include<stdio.h>

void merge(int arr[],int l,int m,int r)
{
    int n1=m-l+1;
    int n2=r-m;

    int L[n1],R[n2];

    for(int i=0;i<n1;i++){
        L[i]=arr[l+i];
    }
    for(int j=0;j<n2;j++)
    {
        R[j]=arr[m+1+j];
    }

    int i=0,j=0,k=l;

    while(i<n1&&j<n2)
    {
        if(L[i]<=R[j])
        {
            arr[k++]=L[i++];
        }
        else
        {
            arr[k++]=R[j++];
        }
    }

    while(i<n1)
    {
        arr[k++]=L[i++];
    }

    while(j<n2)
    {
        arr[k++]=R[j++];
    }
}

void mergeSort(int arr[],int l,int r)
{
    if(l<r)
    {
        int m=(l+(r-1))/2;

        mergeSort(arr,l,m);
        mergeSort(arr,m+1,r);

        merge(arr,l,m,r);
    }

}

int main()
{
    int arr[] = {3,4,1,2,5,6,7};
    int n=7;

    mergeSort(arr, 0, n-1);

   for(int i=0;i<n;i++)
   {
       printf("%d ",arr[i]);
   }

    return 0;
}


If you encountered â€Directory Listing Denied – This Virtual Directory does not allow contents to be listedâ€ error message on Windows Hosting, it is probably because you use index.php as your main file.
By default, HSphere does not include index.php as directory index or main file on Windows Hosting. That means, if you want to use index.php as your main file, you will need to modify your directory index setting in you hosting control panel and put index.php as your directory index.
Read below article for detail info:
This tool allows you to set your own index pages instead of those specified in the default settings. In other words, you can tell your visitorsâ€™ browsers which page to load as they hit your domain. Usually, itâ€™s /index.html by default, but you can set any other custom welcome page.
Example: If a visitor goes to your site http://www.example.com, the first page to open will be http://www.example.com/index.html. However, if you set /welcome.html as the directory index, the page to open will be http://www.example.com/welcome.html.
Warning: your custom index pages wonâ€™t add to the defaults; they will replace them. Therefore, make sure to enter the full list of indexes you would like to have in your configuration.
To set your custom directory indexes, do the following:
- Select Quick Access in the Account menu.
- Click the Web Options icon on the page that shows.
- Click the Edit icon next to the domain you need.
- On the Web Service page, scroll down to find the Directory Indexes option and turn it on.
- Agree with the charges.
- In the box that appears, enter the names for files that will be treated as indexes. Put file names in the descending order of priority and separate them with spaces (e.g. index.html cgi.bin about.html).
- Skip this step if you are using a Windows-based plan. At the top of the Web Service page, click the Apply link for the Server configuration to change. The changes will take effect within 15 minutes.
- To edit the list you have made, click the Edit icon next to the Directory Indexes option: with spaces (e.g. index.html cgi.bin about.html).
If you are using a Unix-based plan, click the Apply link at the top of the Web Service page.